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
  76 /* Local function prototypes */
  77 static char *java_accstring_lookup (int);
  78 static void  classitf_redefinition_error (const char *,tree, tree, tree);
  79 static void  variable_redefinition_error (tree, tree, tree, int);
  80 static tree  create_class (int, tree, tree, tree);
  81 static tree  create_interface (int, tree, tree);
  82 static void  end_class_declaration (int);
  83 static tree  find_field (tree, tree);
  84 static tree lookup_field_wrapper (tree, tree);
  85 static int   duplicate_declaration_error_p (tree, tree, tree);
  86 static void  register_fields (int, tree, tree);
  87 static tree parser_qualified_classname (tree);
  88 static int  parser_check_super (tree, tree, tree);
  89 static int  parser_check_super_interface (tree, tree, tree);
  90 static void check_modifiers_consistency (int);
  91 static tree lookup_cl (tree);
  92 static tree lookup_java_method2 (tree, tree, int);
  93 static tree method_header (int, tree, tree, tree);
  94 static void fix_method_argument_names (tree ,tree);
  95 static tree method_declarator (tree, tree);
  96 static void parse_warning_context (tree cl, const char *msg, ...)
  97   ATTRIBUTE_PRINTF_2;
  98 static void issue_warning_error_from_context (tree, const char *msg, va_list)
  99   ATTRIBUTE_PRINTF (2, 0);
 100 static void parse_ctor_invocation_error (void);
 101 static tree parse_jdk1_1_error (const char *);
 102 static void complete_class_report_errors (jdep *);
 103 static int process_imports (void);
 104 static void read_import_dir (tree);
 105 static int find_in_imports_on_demand (tree, tree);
 106 static void find_in_imports (tree, tree);
 107 static void check_inner_class_access (tree, tree, tree);
 108 static int check_pkg_class_access (tree, tree, bool);
 109 static void register_package (tree);
 110 static tree resolve_package (tree, tree *, tree *);
 111 static tree resolve_class (tree, tree, tree, tree);
 112 static void declare_local_variables (int, tree, tree);
 113 static void dump_java_tree (enum tree_dump_index, tree);
 114 static void source_start_java_method (tree);
 115 static void source_end_java_method (void);
 116 static tree find_name_in_single_imports (tree);
 117 static void check_abstract_method_header (tree);
 118 static tree lookup_java_interface_method2 (tree, tree);
 119 static tree resolve_expression_name (tree, tree *);
 120 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
 121 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
 122 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
 123 static int breakdown_qualified (tree *, tree *, tree);
 124 static int in_same_package (tree, tree);
 125 static tree resolve_and_layout (tree, tree);
 126 static tree qualify_and_find (tree, tree, tree);
 127 static tree resolve_no_layout (tree, tree);
 128 static int invocation_mode (tree, int);
 129 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
 130 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
 131 static tree find_most_specific_methods_list (tree);
 132 static int argument_types_convertible (tree, tree);
 133 static tree patch_invoke (tree, tree, tree);
 134 static int maybe_use_access_method (int, tree *, tree *);
 135 static tree lookup_method_invoke (int, tree, tree, tree, tree);
 136 static tree register_incomplete_type (int, tree, tree, tree);
 137 static tree check_inner_circular_reference (tree, tree);
 138 static tree check_circular_reference (tree);
 139 static tree obtain_incomplete_type (tree);
 140 static tree java_complete_lhs (tree);
 141 static tree java_complete_tree (tree);
 142 static tree maybe_generate_pre_expand_clinit (tree);
 143 static int analyze_clinit_body (tree, tree);
 144 static int maybe_yank_clinit (tree);
 145 static void java_complete_expand_method (tree);
 146 static void java_expand_method_bodies (tree);
 147 static int  unresolved_type_p (tree, tree *);
 148 static void create_jdep_list (struct parser_ctxt *);
 149 static tree build_expr_block (tree, tree);
 150 static tree enter_block (void);
 151 static tree exit_block (void);
 152 static tree lookup_name_in_blocks (tree);
 153 static void maybe_absorb_scoping_blocks (void);
 154 static tree build_method_invocation (tree, tree);
 155 static tree build_new_invocation (tree, tree);
 156 static tree build_assignment (int, int, tree, tree);
 157 static tree build_binop (enum tree_code, int, tree, tree);
 158 static tree patch_assignment (tree, tree);
 159 static tree patch_binop (tree, tree, tree);
 160 static tree build_unaryop (int, int, tree);
 161 static tree build_incdec (int, int, tree, int);
 162 static tree patch_unaryop (tree, tree);
 163 static tree build_cast (int, tree, tree);
 164 static tree build_null_of_type (tree);
 165 static tree patch_cast (tree, tree);
 166 static int valid_ref_assignconv_cast_p (tree, tree, int);
 167 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
 168 static int valid_cast_to_p (tree, tree);
 169 static int valid_method_invocation_conversion_p (tree, tree);
 170 static tree try_builtin_assignconv (tree, tree, tree);
 171 static tree try_reference_assignconv (tree, tree);
 172 static tree build_unresolved_array_type (tree);
 173 static int build_type_name_from_array_name (tree, tree *);
 174 static tree build_array_from_name (tree, tree, tree, tree *);
 175 static tree build_array_ref (int, tree, tree);
 176 static tree patch_array_ref (tree);
 177 static tree make_qualified_name (tree, tree, int);
 178 static tree merge_qualified_name (tree, tree);
 179 static tree make_qualified_primary (tree, tree, int);
 180 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
 181 static void qualify_ambiguous_name (tree);
 182 static tree resolve_field_access (tree, tree *, tree *);
 183 static tree build_newarray_node (tree, tree, int);
 184 static tree patch_newarray (tree);
 185 static tree resolve_type_during_patch (tree);
 186 static tree build_this (int);
 187 static tree build_wfl_wrap (tree, int);
 188 static tree build_return (int, tree);
 189 static tree patch_return (tree);
 190 static tree maybe_access_field (tree, tree, tree);
 191 static int complete_function_arguments (tree);
 192 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
 193 static int not_accessible_p (tree, tree, tree, int);
 194 static void check_deprecation (tree, tree);
 195 static int class_in_current_package (tree);
 196 static tree build_if_else_statement (int, tree, tree, tree);
 197 static tree patch_if_else_statement (tree);
 198 static tree add_stmt_to_compound (tree, tree, tree);
 199 static tree add_stmt_to_block (tree, tree, tree);
 200 static tree patch_exit_expr (tree);
 201 static tree build_labeled_block (int, tree);
 202 static tree finish_labeled_statement (tree, tree);
 203 static tree build_bc_statement (int, int, tree);
 204 static tree patch_bc_statement (tree);
 205 static tree patch_loop_statement (tree);
 206 static tree build_new_loop (tree);
 207 static tree build_loop_body (int, tree, int);
 208 static tree finish_loop_body (int, tree, tree, int);
 209 static tree build_debugable_stmt (int, tree);
 210 static tree finish_for_loop (int, tree, tree, tree);
 211 static tree patch_switch_statement (tree);
 212 static tree string_constant_concatenation (tree, tree);
 213 static tree build_string_concatenation (tree, tree);
 214 static tree patch_string_cst (tree);
 215 static tree patch_string (tree);
 216 static tree encapsulate_with_try_catch (int, tree, tree, tree);
 217 static tree build_assertion (int, tree, tree);
 218 static tree build_try_statement (int, tree, tree);
 219 static tree build_try_finally_statement (int, tree, tree);
 220 static tree patch_try_statement (tree);
 221 static tree patch_synchronized_statement (tree, tree);
 222 static tree patch_throw_statement (tree, tree);
 223 static void check_thrown_exceptions (int, tree, tree);
 224 static int check_thrown_exceptions_do (tree);
 225 static void purge_unchecked_exceptions (tree);
 226 static bool ctors_unchecked_throws_clause_p (tree);
 227 static void check_concrete_throws_clauses (tree, tree, tree, tree);
 228 static void check_throws_clauses (tree, tree, tree);
 229 static void finish_method_declaration (tree);
 230 static tree build_super_invocation (tree);
 231 static int verify_constructor_circularity (tree, tree);
 232 static char *constructor_circularity_msg (tree, tree);
 233 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
 234 static const char *get_printable_method_name (tree);
 235 static tree patch_conditional_expr (tree, tree, tree);
 236 static tree generate_finit (tree);
 237 static tree generate_instinit (tree);
 238 static tree build_instinit_invocation (tree);
 239 static void fix_constructors (tree);
 240 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
 241 static tree craft_constructor (tree, tree);
 242 static int verify_constructor_super (tree);
 243 static tree create_artificial_method (tree, int, tree, tree, tree);
 244 static void start_artificial_method_body (tree);
 245 static void end_artificial_method_body (tree);
 246 static int check_method_redefinition (tree, tree);
 247 static int check_method_types_complete (tree);
 248 static bool hack_is_accessible_p (tree, tree);
 249 static void java_check_regular_methods (tree);
 250 static void check_interface_throws_clauses (tree, tree);
 251 static void java_check_abstract_methods (tree);
 252 static void unreachable_stmt_error (tree);
 253 static int not_accessible_field_error (tree, tree);
 254 static tree find_expr_with_wfl (tree);
 255 static void missing_return_error (tree);
 256 static tree build_new_array_init (int, tree);
 257 static tree patch_new_array_init (tree, tree);
 258 static tree maybe_build_array_element_wfl (tree);
 259 static int array_constructor_check_entry (tree, tree);
 260 static const char *purify_type_name (const char *);
 261 static tree fold_constant_for_init (tree, tree);
 262 static tree strip_out_static_field_access_decl (tree);
 263 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
 264 static void static_ref_err (tree, tree, tree);
 265 static void parser_add_interface (tree, tree, tree);
 266 static void add_superinterfaces (tree, tree);
 267 static tree jdep_resolve_class (jdep *);
 268 static int note_possible_classname (const char *, int);
 269 static void java_complete_expand_classes (void);
 270 static void java_complete_expand_class (tree);
 271 static void java_complete_expand_methods (tree);
 272 static tree cut_identifier_in_qualified (tree);
 273 static tree java_stabilize_reference (tree);
 274 static tree do_unary_numeric_promotion (tree);
 275 static char * operator_string (tree);
 276 static tree do_merge_string_cste (tree, const char *, int, int);
 277 static tree merge_string_cste (tree, tree, int);
 278 static tree java_refold (tree);
 279 static int java_decl_equiv (tree, tree);
 280 static int binop_compound_p (enum tree_code);
 281 static tree search_loop (tree);
 282 static int labeled_block_contains_loop_p (tree, tree);
 283 static int check_abstract_method_definitions (int, tree, tree);
 284 static void java_check_abstract_method_definitions (tree);
 285 static void java_debug_context_do (int);
 286 static void java_parser_context_push_initialized_field (void);
 287 static void java_parser_context_pop_initialized_field (void);
 288 static tree reorder_static_initialized (tree);
 289 static void java_parser_context_suspend (void);
 290 static void java_parser_context_resume (void);
 291 static int pop_current_osb (struct parser_ctxt *);
 292
 293 /* JDK 1.1 work. FIXME */
 294
 295 static tree maybe_make_nested_class_name (tree);
 296 static int make_nested_class_name (tree);
 297 static void set_nested_class_simple_name_value (tree, int);
 298 static void link_nested_class_to_enclosing (void);
 299 static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
 300 static tree find_as_inner_class (tree, tree, tree);
 301 static tree find_as_inner_class_do (tree, tree);
 302 static int check_inner_class_redefinition (tree, tree);
 303
 304 static tree build_thisn_assign (void);
 305 static tree build_current_thisn (tree);
 306 static tree build_access_to_thisn (tree, tree, int);
 307 static tree maybe_build_thisn_access_method (tree);
 308
 309 static tree build_outer_field_access (tree, tree);
 310 static tree build_outer_field_access_methods (tree);
 311 static tree build_outer_field_access_expr (int, tree, tree,
 312                                                   tree, tree);
 313 static tree build_outer_method_access_method (tree);
 314 static tree build_new_access_id (void);
 315 static tree build_outer_field_access_method (tree, tree, tree,
 316                                                     tree, tree);
 317
 318 static int outer_field_access_p (tree, tree);
 319 static int outer_field_expanded_access_p (tree, tree *,
 320                                                  tree *, tree *);
 321 static tree outer_field_access_fix (tree, tree, tree);
 322 static tree build_incomplete_class_ref (int, tree);
 323 static tree patch_incomplete_class_ref (tree);
 324 static tree create_anonymous_class (int, tree);
 325 static void patch_anonymous_class (tree, tree, tree);
 326 static void add_inner_class_fields (tree, tree);
 327
 328 static tree build_dot_class_method (tree);
 329 static tree build_dot_class_method_invocation (tree, tree);
 330 static void create_new_parser_context (int);
 331 static tree maybe_build_class_init_for_field (tree, tree);
 332
 333 static int attach_init_test_initialization_flags (void **, void *);
 334 static int emit_test_initialization (void **, void *);
 335
 336 static char *string_convert_int_cst (tree);
 337
 338 /* Number of error found so far. */
 339 int java_error_count;
 340 /* Number of warning found so far. */
 341 int java_warning_count;
 342 /* Tell when not to fold, when doing xrefs */
 343 int do_not_fold;
 344 /* Cyclic inheritance report, as it can be set by layout_class */
 345 const char *cyclic_inheritance_report;
 346
 347 /* The current parser context */
 348 struct parser_ctxt *ctxp;
 349
 350 /* List of things that were analyzed for which code will be generated */
 351 struct parser_ctxt *ctxp_for_generation = NULL;
 352
 353 /* binop_lookup maps token to tree_code. It is used where binary
 354    operations are involved and required by the parser. RDIV_EXPR
 355    covers both integral/floating point division. The code is changed
 356    once the type of both operator is worked out.  */
 357
 358 static const enum tree_code binop_lookup[19] =
 359   {
 360     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
 361     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
 362     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
 363     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
 364     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
 365    };
 366 #define BINOP_LOOKUP(VALUE)                                             \
 367   binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
 368
 369 /* This is the end index for binary operators that can also be used
 370    in compound assignments. */
 371 #define BINOP_COMPOUND_CANDIDATES 11
 372
 373 /* The "$L" identifier we use to create labels.  */
 374 static GTY(()) tree label_id;
 375
 376 /* The "StringBuffer" identifier used for the String `+' operator. */
 377 static GTY(()) tree wfl_string_buffer;
 378
 379 /* The "append" identifier used for String `+' operator.  */
 380 static GTY(()) tree wfl_append;
 381
 382 /* The "toString" identifier used for String `+' operator. */
 383 static GTY(()) tree wfl_to_string;
 384
 385 /* The "java.lang" import qualified name.  */
 386 static GTY(()) tree java_lang_id;
 387
 388 /* The generated `inst$' identifier used for generated enclosing
 389    instance/field access functions.  */
 390 static GTY(()) tree inst_id;
 391
 392 /* Context and flag for static blocks */
 393 static GTY(()) tree current_static_block;
 394
 395 /* The generated `write_parm_value$' identifier.  */
 396 static GTY(()) tree wpv_id;
 397
 398 /* The list of all packages we've seen so far */
 399 static GTY(()) tree package_list;
 400
 401 /* Hold THIS for the scope of the current method decl.  */
 402 static GTY(()) tree current_this;
 403
 404 /* Hold a list of catch clauses list. The first element of this list is
 405    the list of the catch clauses of the currently analyzed try block. */
 406 static GTY(()) tree currently_caught_type_list;
 407
 408 /* This holds a linked list of all the case labels for the current
 409    switch statement.  It is only used when checking to see if there
 410    are duplicate labels.  FIXME: probably this should just be attached
 411    to the switch itself; then it could be referenced via
 412    `ctxp->current_loop'.  */
 413 static GTY(()) tree case_label_list;
 414
 415 /* Anonymous class counter. Will be reset to 1 every time a non
 416    anonymous class gets created. */
 417 static int anonymous_class_counter = 1;
 418
 419 static GTY(()) tree src_parse_roots[1];
 420
 421 /* All classes seen from source code */
 422 #define gclass_list src_parse_roots[0]
 423
 424 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
 425    line and point it out.  */
 426 /* Should point out the one that don't fit. ASCII/unicode, going
 427    backward. FIXME */
 428
 429 #define check_modifiers(__message, __value, __mask) do {        \
 430   if ((__value) & ~(__mask))                                    \
 431     {                                                           \
 432       size_t i, remainder = (__value) & ~(__mask);              \
 433       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)     \
 434         if ((1 << i) & remainder)                               \
 435           parse_error_context (ctxp->modifier_ctx [i], (__message), \
 436                                java_accstring_lookup (1 << i)); \
 437     }                                                           \
 438 } while (0)
 439
 440 %}
 441
 442 %union {
 443   tree node;
 444   int sub_token;
 445   struct {
 446     int token;
 447     int location;
 448   } operator;
 449   int value;
 450 }
 451
 452 %{
 453 #include "lex.c"
 454 %}
 455
 456 %pure_parser
 457
 458 /* Things defined here have to match the order of what's in the
 459    binop_lookup table.  */
 460
 461 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
 462 %token   LS_TK           SRS_TK          ZRS_TK
 463 %token   AND_TK          XOR_TK          OR_TK
 464 %token   BOOL_AND_TK BOOL_OR_TK
 465 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
 466
 467 /* This maps to the same binop_lookup entry than the token above */
 468
 469 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
 470 %token   REM_ASSIGN_TK
 471 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 472 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
 473
 474
 475 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
 476
 477 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
 478 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
 479 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
 480 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
 481 %token   MODIFIER_TK
 482
 483 /* Keep those two in order, too */
 484 %token   DECR_TK INCR_TK
 485
 486 /* From now one, things can be in any order */
 487
 488 %token   DEFAULT_TK      IF_TK              THROW_TK
 489 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
 490 %token   THROWS_TK       BREAK_TK           IMPORT_TK
 491 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
 492 %token   VOID_TK         CATCH_TK           INTERFACE_TK
 493 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
 494 %token   SUPER_TK        WHILE_TK           CLASS_TK
 495 %token   SWITCH_TK       CONST_TK           TRY_TK
 496 %token   FOR_TK          NEW_TK             CONTINUE_TK
 497 %token   GOTO_TK         PACKAGE_TK         THIS_TK
 498 %token   ASSERT_TK
 499
 500 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
 501 %token   CHAR_TK         INTEGRAL_TK
 502
 503 %token   FLOAT_TK        DOUBLE_TK          FP_TK
 504
 505 %token   ID_TK
 506
 507 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
 508
 509 %token   ASSIGN_ANY_TK   ASSIGN_TK
 510 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
 511
 512 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
 513 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
 514
 515 %type    <value>        modifiers MODIFIER_TK final synchronized
 516
 517 %type    <node>         super ID_TK identifier
 518 %type    <node>         name simple_name qualified_name
 519 %type    <node>         type_declaration compilation_unit
 520                         field_declaration method_declaration extends_interfaces
 521                         interfaces interface_type_list
 522                         import_declarations package_declaration
 523                         type_declarations interface_body
 524                         interface_member_declaration constant_declaration
 525                         interface_member_declarations interface_type
 526                         abstract_method_declaration
 527 %type    <node>         class_body_declaration class_member_declaration
 528                         static_initializer constructor_declaration block
 529 %type    <node>         class_body_declarations constructor_header
 530 %type    <node>         class_or_interface_type class_type class_type_list
 531                         constructor_declarator explicit_constructor_invocation
 532 %type    <node>         dim_expr dim_exprs this_or_super throws
 533
 534 %type    <node>         variable_declarator_id variable_declarator
 535                         variable_declarators variable_initializer
 536                         variable_initializers constructor_body
 537                         array_initializer
 538
 539 %type    <node>         class_body block_end constructor_block_end
 540 %type    <node>         statement statement_without_trailing_substatement
 541                         labeled_statement if_then_statement label_decl
 542                         if_then_else_statement while_statement for_statement
 543                         statement_nsi labeled_statement_nsi do_statement
 544                         if_then_else_statement_nsi while_statement_nsi
 545                         for_statement_nsi statement_expression_list for_init
 546                         for_update statement_expression expression_statement
 547                         primary_no_new_array expression primary
 548                         array_creation_expression array_type
 549                         class_instance_creation_expression field_access
 550                         method_invocation array_access something_dot_new
 551                         argument_list postfix_expression while_expression
 552                         post_increment_expression post_decrement_expression
 553                         unary_expression_not_plus_minus unary_expression
 554                         pre_increment_expression pre_decrement_expression
 555                         cast_expression
 556                         multiplicative_expression additive_expression
 557                         shift_expression relational_expression
 558                         equality_expression and_expression
 559                         exclusive_or_expression inclusive_or_expression
 560                         conditional_and_expression conditional_or_expression
 561                         conditional_expression assignment_expression
 562                         left_hand_side assignment for_header for_begin
 563                         constant_expression do_statement_begin empty_statement
 564                         switch_statement synchronized_statement throw_statement
 565                         try_statement assert_statement
 566                         switch_expression switch_block
 567                         catches catch_clause catch_clause_parameter finally
 568                         anonymous_class_creation trap_overflow_corner_case
 569 %type    <node>         return_statement break_statement continue_statement
 570
 571 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
 572 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
 573 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 574 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
 575 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
 576 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
 577 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
 578 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
 579 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
 580 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
 581 %type    <operator>     THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
 582 %type    <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
 583 %type    <operator>     NEW_TK ASSERT_TK
 584
 585 %type    <node>         method_body
 586
 587 %type    <node>         literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
 588                         STRING_LIT_TK NULL_TK VOID_TK
 589
 590 %type    <node>         IF_TK WHILE_TK FOR_TK
 591
 592 %type    <node>         formal_parameter_list formal_parameter
 593                         method_declarator method_header
 594
 595 %type    <node>         primitive_type reference_type type
 596                         BOOLEAN_TK INTEGRAL_TK FP_TK
 597
 598 /* Added or modified JDK 1.1 rule types  */
 599 %type    <node>         type_literals
 600
 601 %%
 602 /* 19.2 Production from 2.3: The Syntactic Grammar  */
 603 goal:  compilation_unit
 604                 {}
 605 ;
 606
 607 /* 19.3 Productions from 3: Lexical structure  */
 608 literal:
 609         INT_LIT_TK
 610 |       FP_LIT_TK
 611 |       BOOL_LIT_TK
 612 |       CHAR_LIT_TK
 613 |       STRING_LIT_TK
 614 |       NULL_TK
 615 ;
 616
 617 /* 19.4 Productions from 4: Types, Values and Variables  */
 618 type:
 619         primitive_type
 620 |       reference_type
 621 ;
 622
 623 primitive_type:
 624         INTEGRAL_TK
 625 |       FP_TK
 626 |       BOOLEAN_TK
 627 ;
 628
 629 reference_type:
 630         class_or_interface_type
 631 |       array_type
 632 ;
 633
 634 class_or_interface_type:
 635         name
 636 ;
 637
 638 class_type:
 639         class_or_interface_type /* Default rule */
 640 ;
 641
 642 interface_type:
 643          class_or_interface_type
 644 ;
 645
 646 array_type:
 647         primitive_type dims
 648                 {
 649                   int osb = pop_current_osb (ctxp);
 650                   tree t = build_java_array_type (($1), -1);
 651                   while (--osb)
 652                     t = build_unresolved_array_type (t);
 653                   $$ = t;
 654                 }
 655 |       name dims
 656                 {
 657                   int osb = pop_current_osb (ctxp);
 658                   tree t = $1;
 659                   while (osb--)
 660                     t = build_unresolved_array_type (t);
 661                   $$ = t;
 662                 }
 663 ;
 664
 665 /* 19.5 Productions from 6: Names  */
 666 name:
 667         simple_name             /* Default rule */
 668 |       qualified_name          /* Default rule */
 669 ;
 670
 671 simple_name:
 672         identifier              /* Default rule */
 673 ;
 674
 675 qualified_name:
 676         name DOT_TK identifier
 677                 { $$ = make_qualified_name ($1, $3, $2.location); }
 678 ;
 679
 680 identifier:
 681         ID_TK
 682 ;
 683
 684 /* 19.6: Production from 7: Packages  */
 685 compilation_unit:
 686                 {$$ = NULL;}
 687 |       package_declaration
 688 |       import_declarations
 689 |       type_declarations
 690 |       package_declaration import_declarations
 691 |       package_declaration type_declarations
 692 |       import_declarations type_declarations
 693 |       package_declaration import_declarations type_declarations
 694 ;
 695
 696 import_declarations:
 697         import_declaration
 698                 {
 699                   $$ = NULL;
 700                 }
 701 |       import_declarations import_declaration
 702                 {
 703                   $$ = NULL;
 704                 }
 705 ;
 706
 707 type_declarations:
 708         type_declaration
 709 |       type_declarations type_declaration
 710 ;
 711
 712 package_declaration:
 713         PACKAGE_TK name SC_TK
 714                 {
 715                   ctxp->package = EXPR_WFL_NODE ($2);
 716                   register_package (ctxp->package);
 717                 }
 718 |       PACKAGE_TK error
 719                 {yyerror ("Missing name"); RECOVER;}
 720 |       PACKAGE_TK name error
 721                 {yyerror ("';' expected"); RECOVER;}
 722 ;
 723
 724 import_declaration:
 725         single_type_import_declaration
 726 |       type_import_on_demand_declaration
 727 ;
 728
 729 single_type_import_declaration:
 730         IMPORT_TK name SC_TK
 731                 {
 732                   tree name = EXPR_WFL_NODE ($2), last_name;
 733                   int   i = IDENTIFIER_LENGTH (name)-1;
 734                   const char *last = &IDENTIFIER_POINTER (name)[i];
 735                   while (last != IDENTIFIER_POINTER (name))
 736                     {
 737                       if (last [0] == '.')
 738                         break;
 739                       last--;
 740                     }
 741                   last_name = get_identifier (++last);
 742                   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
 743                     {
 744                       tree err = find_name_in_single_imports (last_name);
 745                       if (err && err != name)
 746                         parse_error_context
 747                           ($2, "Ambiguous class: `%s' and `%s'",
 748                            IDENTIFIER_POINTER (name),
 749                            IDENTIFIER_POINTER (err));
 750                       else
 751                         REGISTER_IMPORT ($2, last_name);
 752                     }
 753                   else
 754                     REGISTER_IMPORT ($2, last_name);
 755                 }
 756 |       IMPORT_TK error
 757                 {yyerror ("Missing name"); RECOVER;}
 758 |       IMPORT_TK name error
 759                 {yyerror ("';' expected"); RECOVER;}
 760 ;
 761
 762 type_import_on_demand_declaration:
 763         IMPORT_TK name DOT_TK MULT_TK SC_TK
 764                 {
 765                   tree name = EXPR_WFL_NODE ($2);
 766                   tree it;
 767                   /* Search for duplicates. */
 768                   for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
 769                     if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
 770                       break;
 771                   /* Don't import the same thing more than once, just ignore
 772                      duplicates (7.5.2) */
 773                   if (! it)
 774                     {
 775                       read_import_dir ($2);
 776                       ctxp->import_demand_list =
 777                         chainon (ctxp->import_demand_list,
 778                                  build_tree_list ($2, NULL_TREE));
 779                     }
 780                 }
 781 |       IMPORT_TK name DOT_TK error
 782                 {yyerror ("'*' expected"); RECOVER;}
 783 |       IMPORT_TK name DOT_TK MULT_TK error
 784                 {yyerror ("';' expected"); RECOVER;}
 785 ;
 786
 787 type_declaration:
 788         class_declaration
 789                 { end_class_declaration (0); }
 790 |       interface_declaration
 791                 { end_class_declaration (0); }
 792 |       empty_statement
 793 |       error
 794                 {
 795                   YYERROR_NOW;
 796                   yyerror ("Class or interface declaration expected");
 797                 }
 798 ;
 799
 800 /* 19.7 Shortened from the original:
 801    modifiers: modifier | modifiers modifier
 802    modifier: any of public...  */
 803 modifiers:
 804         MODIFIER_TK
 805                 {
 806                   $$ = (1 << $1);
 807                 }
 808 |       modifiers MODIFIER_TK
 809                 {
 810                   int acc = (1 << $2);
 811                   if ($$ & acc)
 812                     parse_error_context
 813                       (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
 814                        java_accstring_lookup (acc));
 815                   else
 816                     {
 817                       $$ |= acc;
 818                     }
 819                 }
 820 ;
 821
 822 /* 19.8.1 Production from $8.1: Class Declaration */
 823 class_declaration:
 824         modifiers CLASS_TK identifier super interfaces
 825                 { create_class ($1, $3, $4, $5); }
 826         class_body
 827                 {;}
 828 |       CLASS_TK identifier super interfaces
 829                 { create_class (0, $2, $3, $4); }
 830         class_body
 831                 {;}
 832 |       modifiers CLASS_TK error
 833                 { yyerror ("Missing class name"); RECOVER; }
 834 |       CLASS_TK error
 835                 { yyerror ("Missing class name"); RECOVER; }
 836 |       CLASS_TK identifier error
 837                 {
 838                   if (!ctxp->class_err) yyerror ("'{' expected");
 839                   DRECOVER(class1);
 840                 }
 841 |       modifiers CLASS_TK identifier error
 842                 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
 843 ;
 844
 845 super:
 846                 { $$ = NULL; }
 847 |       EXTENDS_TK class_type
 848                 { $$ = $2; }
 849 |       EXTENDS_TK class_type error
 850                 {yyerror ("'{' expected"); ctxp->class_err=1;}
 851 |       EXTENDS_TK error
 852                 {yyerror ("Missing super class name"); ctxp->class_err=1;}
 853 ;
 854
 855 interfaces:
 856                 { $$ = NULL_TREE; }
 857 |       IMPLEMENTS_TK interface_type_list
 858                 { $$ = $2; }
 859 |       IMPLEMENTS_TK error
 860                 {
 861                   ctxp->class_err=1;
 862                   yyerror ("Missing interface name");
 863                 }
 864 ;
 865
 866 interface_type_list:
 867         interface_type
 868                 {
 869                   ctxp->interface_number = 1;
 870                   $$ = build_tree_list ($1, NULL_TREE);
 871                 }
 872 |       interface_type_list C_TK interface_type
 873                 {
 874                   ctxp->interface_number++;
 875                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
 876                 }
 877 |       interface_type_list C_TK error
 878                 {yyerror ("Missing interface name"); RECOVER;}
 879 ;
 880
 881 class_body:
 882         OCB_TK CCB_TK
 883                 {
 884                   /* Store the location of the `}' when doing xrefs */
 885                   if (flag_emit_xref)
 886                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 887                       EXPR_WFL_ADD_COL ($2.location, 1);
 888                   $$ = GET_CPC ();
 889                 }
 890 |       OCB_TK class_body_declarations CCB_TK
 891                 {
 892                   /* Store the location of the `}' when doing xrefs */
 893                   if (flag_emit_xref)
 894                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 895                       EXPR_WFL_ADD_COL ($3.location, 1);
 896                   $$ = GET_CPC ();
 897                 }
 898 ;
 899
 900 class_body_declarations:
 901         class_body_declaration
 902 |       class_body_declarations class_body_declaration
 903 ;
 904
 905 class_body_declaration:
 906         class_member_declaration
 907 |       static_initializer
 908 |       constructor_declaration
 909 |       block                   /* Added, JDK1.1, instance initializer */
 910                 {
 911                   if ($1 != empty_stmt_node)
 912                     {
 913                       TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
 914                       SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
 915                     }
 916                 }
 917 ;
 918
 919 class_member_declaration:
 920         field_declaration
 921 |       method_declaration
 922 |       class_declaration       /* Added, JDK1.1 inner classes */
 923                 { end_class_declaration (1); }
 924 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
 925                 { end_class_declaration (1); }
 926 |       empty_statement
 927 ;
 928
 929 /* 19.8.2 Productions from 8.3: Field Declarations  */
 930 field_declaration:
 931         type variable_declarators SC_TK
 932                 { register_fields (0, $1, $2); }
 933 |       modifiers type variable_declarators SC_TK
 934                 {
 935                   check_modifiers
 936                     ("Illegal modifier `%s' for field declaration",
 937                      $1, FIELD_MODIFIERS);
 938                   check_modifiers_consistency ($1);
 939                   register_fields ($1, $2, $3);
 940                 }
 941 ;
 942
 943 variable_declarators:
 944         /* Should we use build_decl_list () instead ? FIXME */
 945         variable_declarator     /* Default rule */
 946 |       variable_declarators C_TK variable_declarator
 947                 { $$ = chainon ($1, $3); }
 948 |       variable_declarators C_TK error
 949                 {yyerror ("Missing term"); RECOVER;}
 950 ;
 951
 952 variable_declarator:
 953         variable_declarator_id
 954                 { $$ = build_tree_list ($1, NULL_TREE); }
 955 |       variable_declarator_id ASSIGN_TK variable_initializer
 956                 {
 957                   if (java_error_count)
 958                     $3 = NULL_TREE;
 959                   $$ = build_tree_list
 960                     ($1, build_assignment ($2.token, $2.location, $1, $3));
 961                 }
 962 |       variable_declarator_id ASSIGN_TK error
 963                 {
 964                   yyerror ("Missing variable initializer");
 965                   $$ = build_tree_list ($1, NULL_TREE);
 966                   RECOVER;
 967                 }
 968 |       variable_declarator_id ASSIGN_TK variable_initializer error
 969                 {
 970                   yyerror ("';' expected");
 971                   $$ = build_tree_list ($1, NULL_TREE);
 972                   RECOVER;
 973                 }
 974 ;
 975
 976 variable_declarator_id:
 977         identifier
 978 |       variable_declarator_id OSB_TK CSB_TK
 979                 { $$ = build_unresolved_array_type ($1); }
 980 |       identifier error
 981                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
 982 |       variable_declarator_id OSB_TK error
 983                 {
 984                   yyerror ("']' expected");
 985                   DRECOVER(vdi);
 986                 }
 987 |       variable_declarator_id CSB_TK error
 988                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
 989 ;
 990
 991 variable_initializer:
 992         expression
 993 |       array_initializer
 994 ;
 995
 996 /* 19.8.3 Productions from 8.4: Method Declarations  */
 997 method_declaration:
 998         method_header
 999                 {
1000                   current_function_decl = $1;
1001                   if (current_function_decl
1002                       && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1003                     source_start_java_method (current_function_decl);
1004                   else
1005                     current_function_decl = NULL_TREE;
1006                 }
1007         method_body
1008                 { finish_method_declaration ($3); }
1009 |       method_header error
1010                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1011 ;
1012
1013 method_header:
1014         type method_declarator throws
1015                 { $$ = method_header (0, $1, $2, $3); }
1016 |       VOID_TK method_declarator throws
1017                 { $$ = method_header (0, void_type_node, $2, $3); }
1018 |       modifiers type method_declarator throws
1019                 { $$ = method_header ($1, $2, $3, $4); }
1020 |       modifiers VOID_TK method_declarator throws
1021                 { $$ = method_header ($1, void_type_node, $3, $4); }
1022 |       type error
1023                 {
1024                   yyerror ("Invalid method declaration, method name required");
1025                   RECOVER;
1026                 }
1027 |       modifiers type error
1028                 {
1029                   yyerror ("Identifier expected");
1030                   RECOVER;
1031                 }
1032 |       VOID_TK error
1033                 {
1034                   yyerror ("Identifier expected");
1035                   RECOVER;
1036                 }
1037 |       modifiers VOID_TK error
1038                 {
1039                   yyerror ("Identifier expected");
1040                   RECOVER;
1041                 }
1042 |       modifiers error
1043                 {
1044                   yyerror ("Invalid method declaration, return type required");
1045                   RECOVER;
1046                 }
1047 ;
1048
1049 method_declarator:
1050         identifier OP_TK CP_TK
1051                 {
1052                   ctxp->formal_parameter_number = 0;
1053                   $$ = method_declarator ($1, NULL_TREE);
1054                 }
1055 |       identifier OP_TK formal_parameter_list CP_TK
1056                 { $$ = method_declarator ($1, $3); }
1057 |       method_declarator OSB_TK CSB_TK
1058                 {
1059                   EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1060                   TREE_PURPOSE ($1) =
1061                     build_unresolved_array_type (TREE_PURPOSE ($1));
1062                   parse_warning_context
1063                     (wfl_operator,
1064                      "Discouraged form of returned type specification");
1065                 }
1066 |       identifier OP_TK error
1067                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1068 |       method_declarator OSB_TK error
1069                 {yyerror ("']' expected"); RECOVER;}
1070 ;
1071
1072 formal_parameter_list:
1073         formal_parameter
1074                 {
1075                   ctxp->formal_parameter_number = 1;
1076                 }
1077 |       formal_parameter_list C_TK formal_parameter
1078                 {
1079                   ctxp->formal_parameter_number += 1;
1080                   $$ = chainon ($1, $3);
1081                 }
1082 |       formal_parameter_list C_TK error
1083                 { yyerror ("Missing formal parameter term"); RECOVER; }
1084 ;
1085
1086 formal_parameter:
1087         type variable_declarator_id
1088                 {
1089                   $$ = build_tree_list ($2, $1);
1090                 }
1091 |       final type variable_declarator_id /* Added, JDK1.1 final parms */
1092                 {
1093                   $$ = build_tree_list ($3, $2);
1094                   ARG_FINAL_P ($$) = 1;
1095                 }
1096 |       type error
1097                 {
1098                   yyerror ("Missing identifier"); RECOVER;
1099                   $$ = NULL_TREE;
1100                 }
1101 |       final type error
1102                 {
1103                   yyerror ("Missing identifier"); RECOVER;
1104                   $$ = NULL_TREE;
1105                 }
1106 ;
1107
1108 final:
1109         modifiers
1110                 {
1111                   check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1112                                    $1, ACC_FINAL);
1113                   if ($1 != ACC_FINAL)
1114                     MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1115                 }
1116 ;
1117
1118 throws:
1119                 { $$ = NULL_TREE; }
1120 |       THROWS_TK class_type_list
1121                 { $$ = $2; }
1122 |       THROWS_TK error
1123                 {yyerror ("Missing class type term"); RECOVER;}
1124 ;
1125
1126 class_type_list:
1127         class_type
1128                 { $$ = build_tree_list ($1, $1); }
1129 |       class_type_list C_TK class_type
1130                 { $$ = tree_cons ($3, $3, $1); }
1131 |       class_type_list C_TK error
1132                 {yyerror ("Missing class type term"); RECOVER;}
1133 ;
1134
1135 method_body:
1136         block
1137 |       SC_TK { $$ = NULL_TREE; }
1138 ;
1139
1140 /* 19.8.4 Productions from 8.5: Static Initializers  */
1141 static_initializer:
1142         static block
1143                 {
1144                   TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1145                   SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1146                   current_static_block = NULL_TREE;
1147                 }
1148 ;
1149
1150 static:                         /* Test lval.sub_token here */
1151         modifiers
1152                 {
1153                   check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1154                   /* Can't have a static initializer in an innerclass */
1155                   if ($1 | ACC_STATIC &&
1156                       GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1157                     parse_error_context
1158                       (MODIFIER_WFL (STATIC_TK),
1159                        "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1160                        IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1161                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1162                 }
1163 ;
1164
1165 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1166 constructor_declaration:
1167         constructor_header
1168                 {
1169                   current_function_decl = $1;
1170                   source_start_java_method (current_function_decl);
1171                 }
1172         constructor_body
1173                 { finish_method_declaration ($3); }
1174 ;
1175
1176 constructor_header:
1177         constructor_declarator throws
1178                 { $$ = method_header (0, NULL_TREE, $1, $2); }
1179 |       modifiers constructor_declarator throws
1180                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1181 ;
1182
1183 constructor_declarator:
1184         simple_name OP_TK CP_TK
1185                 {
1186                   ctxp->formal_parameter_number = 0;
1187                   $$ = method_declarator ($1, NULL_TREE);
1188                 }
1189 |       simple_name OP_TK formal_parameter_list CP_TK
1190                 { $$ = method_declarator ($1, $3); }
1191 ;
1192
1193 constructor_body:
1194         /* Unlike regular method, we always need a complete (empty)
1195            body so we can safely perform all the required code
1196            addition (super invocation and field initialization) */
1197         block_begin constructor_block_end
1198                 {
1199                   BLOCK_EXPR_BODY ($2) = empty_stmt_node;
1200                   $$ = $2;
1201                 }
1202 |       block_begin explicit_constructor_invocation constructor_block_end
1203                 { $$ = $3; }
1204 |       block_begin block_statements constructor_block_end
1205                 { $$ = $3; }
1206 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1207                 { $$ = $4; }
1208 ;
1209
1210 constructor_block_end:
1211         block_end
1212 ;
1213
1214 /* Error recovery for that rule moved down expression_statement: rule.  */
1215 explicit_constructor_invocation:
1216         this_or_super OP_TK CP_TK SC_TK
1217                 {
1218                   $$ = build_method_invocation ($1, NULL_TREE);
1219                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1220                   $$ = java_method_add_stmt (current_function_decl, $$);
1221                 }
1222 |       this_or_super OP_TK argument_list CP_TK SC_TK
1223                 {
1224                   $$ = build_method_invocation ($1, $3);
1225                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1226                   $$ = java_method_add_stmt (current_function_decl, $$);
1227                 }
1228         /* Added, JDK1.1 inner classes. Modified because the rule
1229            'primary' couldn't work.  */
1230 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1231                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1232 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1233                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1234 ;
1235
1236 this_or_super:                  /* Added, simplifies error diagnostics */
1237         THIS_TK
1238                 {
1239                   tree wfl = build_wfl_node (this_identifier_node);
1240                   EXPR_WFL_LINECOL (wfl) = $1.location;
1241                   $$ = wfl;
1242                 }
1243 |       SUPER_TK
1244                 {
1245                   tree wfl = build_wfl_node (super_identifier_node);
1246                   EXPR_WFL_LINECOL (wfl) = $1.location;
1247                   $$ = wfl;
1248                 }
1249 ;
1250
1251 /* 19.9 Productions from 9: Interfaces  */
1252 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1253 interface_declaration:
1254         INTERFACE_TK identifier
1255                 { create_interface (0, $2, NULL_TREE); }
1256         interface_body
1257                 { ; }
1258 |       modifiers INTERFACE_TK identifier
1259                 { create_interface ($1, $3, NULL_TREE); }
1260         interface_body
1261                 { ; }
1262 |       INTERFACE_TK identifier extends_interfaces
1263                 { create_interface (0, $2, $3); }
1264         interface_body
1265                 { ; }
1266 |       modifiers INTERFACE_TK identifier extends_interfaces
1267                 { create_interface ($1, $3, $4); }
1268         interface_body
1269                 { ; }
1270 |       INTERFACE_TK identifier error
1271                 { yyerror ("'{' expected"); RECOVER; }
1272 |       modifiers INTERFACE_TK identifier error
1273                 { yyerror ("'{' expected"); RECOVER; }
1274 ;
1275
1276 extends_interfaces:
1277         EXTENDS_TK interface_type
1278                 {
1279                   ctxp->interface_number = 1;
1280                   $$ = build_tree_list ($2, NULL_TREE);
1281                 }
1282 |       extends_interfaces C_TK interface_type
1283                 {
1284                   ctxp->interface_number++;
1285                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1286                 }
1287 |       EXTENDS_TK error
1288                 {yyerror ("Invalid interface type"); RECOVER;}
1289 |       extends_interfaces C_TK error
1290                 {yyerror ("Missing term"); RECOVER;}
1291 ;
1292
1293 interface_body:
1294         OCB_TK CCB_TK
1295                 { $$ = NULL_TREE; }
1296 |       OCB_TK interface_member_declarations CCB_TK
1297                 { $$ = NULL_TREE; }
1298 ;
1299
1300 interface_member_declarations:
1301         interface_member_declaration
1302 |       interface_member_declarations interface_member_declaration
1303 ;
1304
1305 interface_member_declaration:
1306         constant_declaration
1307 |       abstract_method_declaration
1308 |       class_declaration       /* Added, JDK1.1 inner classes */
1309                 { end_class_declaration (1); }
1310 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
1311                 { end_class_declaration (1); }
1312 ;
1313
1314 constant_declaration:
1315         field_declaration
1316 ;
1317
1318 abstract_method_declaration:
1319         method_header SC_TK
1320                 {
1321                   check_abstract_method_header ($1);
1322                   current_function_decl = NULL_TREE; /* FIXME ? */
1323                 }
1324 |       method_header error
1325                 {yyerror ("';' expected"); RECOVER;}
1326 ;
1327
1328 /* 19.10 Productions from 10: Arrays  */
1329 array_initializer:
1330         OCB_TK CCB_TK
1331                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1332 |       OCB_TK C_TK CCB_TK
1333                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1334 |       OCB_TK variable_initializers CCB_TK
1335                 { $$ = build_new_array_init ($1.location, $2); }
1336 |       OCB_TK variable_initializers C_TK CCB_TK
1337                 { $$ = build_new_array_init ($1.location, $2); }
1338 ;
1339
1340 variable_initializers:
1341         variable_initializer
1342                 {
1343                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1344                                   $1, NULL_TREE);
1345                 }
1346 |       variable_initializers C_TK variable_initializer
1347                 {
1348                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1349                 }
1350 |       variable_initializers C_TK error
1351                 {yyerror ("Missing term"); RECOVER;}
1352 ;
1353
1354 /* 19.11 Production from 14: Blocks and Statements  */
1355 block:
1356         block_begin block_end
1357                 { $$ = $2; }
1358 |       block_begin block_statements block_end
1359                 { $$ = $3; }
1360 ;
1361
1362 block_begin:
1363         OCB_TK
1364                 { enter_block (); }
1365 ;
1366
1367 block_end:
1368         CCB_TK
1369                 {
1370                   maybe_absorb_scoping_blocks ();
1371                   /* Store the location of the `}' when doing xrefs */
1372                   if (current_function_decl && flag_emit_xref)
1373                     DECL_END_SOURCE_LINE (current_function_decl) =
1374                       EXPR_WFL_ADD_COL ($1.location, 1);
1375                   $$ = exit_block ();
1376                   if (!BLOCK_SUBBLOCKS ($$))
1377                     BLOCK_SUBBLOCKS ($$) = empty_stmt_node;
1378                 }
1379 ;
1380
1381 block_statements:
1382         block_statement
1383 |       block_statements block_statement
1384 ;
1385
1386 block_statement:
1387         local_variable_declaration_statement
1388 |       statement
1389                 { java_method_add_stmt (current_function_decl, $1); }
1390 |       class_declaration       /* Added, JDK1.1 local classes */
1391                 {
1392                   LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1393                   end_class_declaration (1);
1394                 }
1395 ;
1396
1397 local_variable_declaration_statement:
1398         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1399 ;
1400
1401 local_variable_declaration:
1402         type variable_declarators
1403                 { declare_local_variables (0, $1, $2); }
1404 |       final type variable_declarators /* Added, JDK1.1 final locals */
1405                 { declare_local_variables ($1, $2, $3); }
1406 ;
1407
1408 statement:
1409         statement_without_trailing_substatement
1410 |       labeled_statement
1411 |       if_then_statement
1412 |       if_then_else_statement
1413 |       while_statement
1414 |       for_statement
1415                 { $$ = exit_block (); }
1416 ;
1417
1418 statement_nsi:
1419         statement_without_trailing_substatement
1420 |       labeled_statement_nsi
1421 |       if_then_else_statement_nsi
1422 |       while_statement_nsi
1423 |       for_statement_nsi
1424                 { $$ = exit_block (); }
1425 ;
1426
1427 statement_without_trailing_substatement:
1428         block
1429 |       empty_statement
1430 |       expression_statement
1431 |       switch_statement
1432 |       do_statement
1433 |       break_statement
1434 |       continue_statement
1435 |       return_statement
1436 |       synchronized_statement
1437 |       throw_statement
1438 |       try_statement
1439 |       assert_statement
1440 ;
1441
1442 empty_statement:
1443         SC_TK
1444                 {
1445                   if (flag_extraneous_semicolon
1446                       && ! current_static_block
1447                       && (! current_function_decl ||
1448                           /* Verify we're not in a inner class declaration */
1449                           (GET_CPC () != TYPE_NAME
1450                            (DECL_CONTEXT (current_function_decl)))))
1451
1452                     {
1453                       EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1454                       parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1455                     }
1456                   $$ = empty_stmt_node;
1457                 }
1458 ;
1459
1460 label_decl:
1461         identifier REL_CL_TK
1462                 {
1463                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1464                                             EXPR_WFL_NODE ($1));
1465                   pushlevel (2);
1466                   push_labeled_block ($$);
1467                   PUSH_LABELED_BLOCK ($$);
1468                 }
1469 ;
1470
1471 labeled_statement:
1472         label_decl statement
1473                 { $$ = finish_labeled_statement ($1, $2); }
1474 |       identifier error
1475                 {yyerror ("':' expected"); RECOVER;}
1476 ;
1477
1478 labeled_statement_nsi:
1479         label_decl statement_nsi
1480                 { $$ = finish_labeled_statement ($1, $2); }
1481 ;
1482
1483 /* We concentrate here a bunch of error handling rules that we couldn't write
1484    earlier, because expression_statement catches a missing ';'.  */
1485 expression_statement:
1486         statement_expression SC_TK
1487                 {
1488                   /* We have a statement. Generate a WFL around it so
1489                      we can debug it */
1490                   $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1491                   /* We know we have a statement, so set the debug
1492                      info to be eventually generate here. */
1493                   $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1494                 }
1495 |       error SC_TK
1496                 {
1497                   YYNOT_TWICE yyerror ("Invalid expression statement");
1498                   DRECOVER (expr_stmt);
1499                 }
1500 |       error OCB_TK
1501                 {
1502                   YYNOT_TWICE yyerror ("Invalid expression statement");
1503                   DRECOVER (expr_stmt);
1504                 }
1505 |       error CCB_TK
1506                 {
1507                   YYNOT_TWICE yyerror ("Invalid expression statement");
1508                   DRECOVER (expr_stmt);
1509                 }
1510 |       this_or_super OP_TK error
1511                 {yyerror ("')' expected"); RECOVER;}
1512 |       this_or_super OP_TK CP_TK error
1513                 {
1514                   parse_ctor_invocation_error ();
1515                   RECOVER;
1516                 }
1517 |       this_or_super OP_TK argument_list error
1518                 {yyerror ("')' expected"); RECOVER;}
1519 |       this_or_super OP_TK argument_list CP_TK error
1520                 {
1521                   parse_ctor_invocation_error ();
1522                   RECOVER;
1523                 }
1524 |       name DOT_TK SUPER_TK error
1525                 {yyerror ("'(' expected"); RECOVER;}
1526 |       name DOT_TK SUPER_TK OP_TK error
1527                 {yyerror ("')' expected"); RECOVER;}
1528 |       name DOT_TK SUPER_TK OP_TK argument_list error
1529                 {yyerror ("')' expected"); RECOVER;}
1530 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1531                 {yyerror ("';' expected"); RECOVER;}
1532 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1533                 {yyerror ("';' expected"); RECOVER;}
1534 ;
1535
1536 statement_expression:
1537         assignment
1538 |       pre_increment_expression
1539 |       pre_decrement_expression
1540 |       post_increment_expression
1541 |       post_decrement_expression
1542 |       method_invocation
1543 |       class_instance_creation_expression
1544 ;
1545
1546 if_then_statement:
1547         IF_TK OP_TK expression CP_TK statement
1548                 {
1549                   $$ = build_if_else_statement ($2.location, $3,
1550                                                 $5, NULL_TREE);
1551                 }
1552 |       IF_TK error
1553                 {yyerror ("'(' expected"); RECOVER;}
1554 |       IF_TK OP_TK error
1555                 {yyerror ("Missing term"); RECOVER;}
1556 |       IF_TK OP_TK expression error
1557                 {yyerror ("')' expected"); RECOVER;}
1558 ;
1559
1560 if_then_else_statement:
1561         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1562                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1563 ;
1564
1565 if_then_else_statement_nsi:
1566         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1567                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1568 ;
1569
1570 switch_statement:
1571         switch_expression
1572                 {
1573                   enter_block ();
1574                 }
1575         switch_block
1576                 {
1577                   /* Make into "proper list" of COMPOUND_EXPRs.
1578                      I.e. make the last statement also have its own
1579                      COMPOUND_EXPR. */
1580                   maybe_absorb_scoping_blocks ();
1581                   TREE_OPERAND ($1, 1) = exit_block ();
1582                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1583                 }
1584 ;
1585
1586 switch_expression:
1587         SWITCH_TK OP_TK expression CP_TK
1588                 {
1589                   $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1590                   EXPR_WFL_LINECOL ($$) = $2.location;
1591                 }
1592 |       SWITCH_TK error
1593                 {yyerror ("'(' expected"); RECOVER;}
1594 |       SWITCH_TK OP_TK error
1595                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1596 |       SWITCH_TK OP_TK expression CP_TK error
1597                 {yyerror ("'{' expected"); RECOVER;}
1598 ;
1599
1600 /* Default assignment is there to avoid type node on switch_block
1601    node. */
1602
1603 switch_block:
1604         OCB_TK CCB_TK
1605                 { $$ = NULL_TREE; }
1606 |       OCB_TK switch_labels CCB_TK
1607                 { $$ = NULL_TREE; }
1608 |       OCB_TK switch_block_statement_groups CCB_TK
1609                 { $$ = NULL_TREE; }
1610 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1611                 { $$ = NULL_TREE; }
1612 ;
1613
1614 switch_block_statement_groups:
1615         switch_block_statement_group
1616 |       switch_block_statement_groups switch_block_statement_group
1617 ;
1618
1619 switch_block_statement_group:
1620         switch_labels block_statements
1621 ;
1622
1623 switch_labels:
1624         switch_label
1625 |       switch_labels switch_label
1626 ;
1627
1628 switch_label:
1629         CASE_TK constant_expression REL_CL_TK
1630                 {
1631                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1632                   EXPR_WFL_LINECOL (lab) = $1.location;
1633                   java_method_add_stmt (current_function_decl, lab);
1634                 }
1635 |       DEFAULT_TK REL_CL_TK
1636                 {
1637                   tree lab = build (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
1638                   EXPR_WFL_LINECOL (lab) = $1.location;
1639                   java_method_add_stmt (current_function_decl, lab);
1640                 }
1641 |       CASE_TK error
1642                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1643 |       CASE_TK constant_expression error
1644                 {yyerror ("':' expected"); RECOVER;}
1645 |       DEFAULT_TK error
1646                 {yyerror ("':' expected"); RECOVER;}
1647 ;
1648
1649 while_expression:
1650         WHILE_TK OP_TK expression CP_TK
1651                 {
1652                   tree body = build_loop_body ($2.location, $3, 0);
1653                   $$ = build_new_loop (body);
1654                 }
1655 ;
1656
1657 while_statement:
1658         while_expression statement
1659                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1660 |       WHILE_TK error
1661                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1662 |       WHILE_TK OP_TK error
1663                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1664 |       WHILE_TK OP_TK expression error
1665                 {yyerror ("')' expected"); RECOVER;}
1666 ;
1667
1668 while_statement_nsi:
1669         while_expression statement_nsi
1670                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1671 ;
1672
1673 do_statement_begin:
1674         DO_TK
1675                 {
1676                   tree body = build_loop_body (0, NULL_TREE, 1);
1677                   $$ = build_new_loop (body);
1678                 }
1679         /* Need error handing here. FIXME */
1680 ;
1681
1682 do_statement:
1683         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1684                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1685 ;
1686
1687 for_statement:
1688         for_begin SC_TK expression SC_TK for_update CP_TK statement
1689                 {
1690                   if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1691                     $3 = build_wfl_node ($3);
1692                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1693                 }
1694 |       for_begin SC_TK SC_TK for_update CP_TK statement
1695                 {
1696                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1697                   /* We have not condition, so we get rid of the EXIT_EXPR */
1698                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1699                     empty_stmt_node;
1700                 }
1701 |       for_begin SC_TK error
1702                 {yyerror ("Invalid control expression"); RECOVER;}
1703 |       for_begin SC_TK expression SC_TK error
1704                 {yyerror ("Invalid update expression"); RECOVER;}
1705 |       for_begin SC_TK SC_TK error
1706                 {yyerror ("Invalid update expression"); RECOVER;}
1707 ;
1708
1709 for_statement_nsi:
1710         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1711                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1712 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1713                 {
1714                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1715                   /* We have not condition, so we get rid of the EXIT_EXPR */
1716                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1717                     empty_stmt_node;
1718                 }
1719 ;
1720
1721 for_header:
1722         FOR_TK OP_TK
1723                 {
1724                   /* This scope defined for local variable that may be
1725                      defined within the scope of the for loop */
1726                   enter_block ();
1727                 }
1728 |       FOR_TK error
1729                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1730 |       FOR_TK OP_TK error
1731                 {yyerror ("Invalid init statement"); RECOVER;}
1732 ;
1733
1734 for_begin:
1735         for_header for_init
1736                 {
1737                   /* We now declare the loop body. The loop is
1738                      declared as a for loop. */
1739                   tree body = build_loop_body (0, NULL_TREE, 0);
1740                   $$ =  build_new_loop (body);
1741                   FOR_LOOP_P ($$) = 1;
1742                   /* The loop is added to the current block the for
1743                      statement is defined within */
1744                   java_method_add_stmt (current_function_decl, $$);
1745                 }
1746 ;
1747 for_init:                       /* Can be empty */
1748                 { $$ = empty_stmt_node; }
1749 |       statement_expression_list
1750                 {
1751                   /* Init statement recorded within the previously
1752                      defined block scope */
1753                   $$ = java_method_add_stmt (current_function_decl, $1);
1754                 }
1755 |       local_variable_declaration
1756                 {
1757                   /* Local variable are recorded within the previously
1758                      defined block scope */
1759                   $$ = NULL_TREE;
1760                 }
1761 |       statement_expression_list error
1762                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1763 ;
1764
1765 for_update:                     /* Can be empty */
1766                 {$$ = empty_stmt_node;}
1767 |       statement_expression_list
1768                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1769 ;
1770
1771 statement_expression_list:
1772         statement_expression
1773                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1774 |       statement_expression_list C_TK statement_expression
1775                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1776 |       statement_expression_list C_TK error
1777                 {yyerror ("Missing term"); RECOVER;}
1778 ;
1779
1780 break_statement:
1781         BREAK_TK SC_TK
1782                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1783 |       BREAK_TK identifier SC_TK
1784                 { $$ = build_bc_statement ($1.location, 1, $2); }
1785 |       BREAK_TK error
1786                 {yyerror ("Missing term"); RECOVER;}
1787 |       BREAK_TK identifier error
1788                 {yyerror ("';' expected"); RECOVER;}
1789 ;
1790
1791 continue_statement:
1792         CONTINUE_TK SC_TK
1793                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1794 |       CONTINUE_TK identifier SC_TK
1795                 { $$ = build_bc_statement ($1.location, 0, $2); }
1796 |       CONTINUE_TK error
1797                 {yyerror ("Missing term"); RECOVER;}
1798 |       CONTINUE_TK identifier error
1799                 {yyerror ("';' expected"); RECOVER;}
1800 ;
1801
1802 return_statement:
1803         RETURN_TK SC_TK
1804                 { $$ = build_return ($1.location, NULL_TREE); }
1805 |       RETURN_TK expression SC_TK
1806                 { $$ = build_return ($1.location, $2); }
1807 |       RETURN_TK error
1808                 {yyerror ("Missing term"); RECOVER;}
1809 |       RETURN_TK expression error
1810                 {yyerror ("';' expected"); RECOVER;}
1811 ;
1812
1813 throw_statement:
1814         THROW_TK expression SC_TK
1815                 {
1816                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1817                   EXPR_WFL_LINECOL ($$) = $1.location;
1818                 }
1819 |       THROW_TK error
1820                 {yyerror ("Missing term"); RECOVER;}
1821 |       THROW_TK expression error
1822                 {yyerror ("';' expected"); RECOVER;}
1823 ;
1824
1825 assert_statement:
1826         ASSERT_TK expression REL_CL_TK expression SC_TK
1827                 {
1828                   $$ = build_assertion ($1.location, $2, $4);
1829                 }
1830 |       ASSERT_TK expression SC_TK
1831                 {
1832                   $$ = build_assertion ($1.location, $2, NULL_TREE);
1833                 }
1834 |       ASSERT_TK error
1835                 {yyerror ("Missing term"); RECOVER;}
1836 |       ASSERT_TK expression error
1837                 {yyerror ("';' expected"); RECOVER;}
1838 ;
1839
1840 synchronized_statement:
1841         synchronized OP_TK expression CP_TK block
1842                 {
1843                   $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1844                   EXPR_WFL_LINECOL ($$) =
1845                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1846                 }
1847 |       synchronized OP_TK expression CP_TK error
1848                 {yyerror ("'{' expected"); RECOVER;}
1849 |       synchronized error
1850                 {yyerror ("'(' expected"); RECOVER;}
1851 |       synchronized OP_TK error CP_TK
1852                 {yyerror ("Missing term"); RECOVER;}
1853 |       synchronized OP_TK error
1854                 {yyerror ("Missing term"); RECOVER;}
1855 ;
1856
1857 synchronized:
1858         modifiers
1859                 {
1860                   check_modifiers (
1861              "Illegal modifier `%s'. Only `synchronized' was expected here",
1862                                    $1, ACC_SYNCHRONIZED);
1863                   if ($1 != ACC_SYNCHRONIZED)
1864                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1865                       build_wfl_node (NULL_TREE);
1866                 }
1867 ;
1868
1869 try_statement:
1870         TRY_TK block catches
1871                 { $$ = build_try_statement ($1.location, $2, $3); }
1872 |       TRY_TK block finally
1873                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1874 |       TRY_TK block catches finally
1875                 { $$ = build_try_finally_statement
1876                     ($1.location, build_try_statement ($1.location,
1877                                                        $2, $3), $4);
1878                 }
1879 |       TRY_TK error
1880                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1881 ;
1882
1883 catches:
1884         catch_clause
1885 |       catches catch_clause
1886                 {
1887                   TREE_CHAIN ($2) = $1;
1888                   $$ = $2;
1889                 }
1890 ;
1891
1892 catch_clause:
1893         catch_clause_parameter block
1894                 {
1895                   java_method_add_stmt (current_function_decl, $2);
1896                   exit_block ();
1897                   $$ = $1;
1898                 }
1899 ;
1900
1901 catch_clause_parameter:
1902         CATCH_TK OP_TK formal_parameter CP_TK
1903                 {
1904                   /* We add a block to define a scope for
1905                      formal_parameter (CCBP). The formal parameter is
1906                      declared initialized by the appropriate function
1907                      call */
1908                   tree ccpb;
1909                   tree init;
1910                   if ($3)
1911                     {
1912                       ccpb = enter_block ();
1913                       init = build_assignment
1914                         (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1915                          build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1916                       declare_local_variables (0, TREE_VALUE ($3),
1917                                                build_tree_list
1918                                                (TREE_PURPOSE ($3), init));
1919                       $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1920                       EXPR_WFL_LINECOL ($$) = $1.location;
1921                     }
1922                   else
1923                     {
1924                       $$ = error_mark_node;
1925                     }
1926                 }
1927 |       CATCH_TK error
1928                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1929 |       CATCH_TK OP_TK error
1930                 {
1931                   yyerror ("Missing term or ')' expected");
1932                   RECOVER; $$ = NULL_TREE;
1933                 }
1934 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1935                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1936 ;
1937
1938 finally:
1939         FINALLY_TK block
1940                 { $$ = $2; }
1941 |       FINALLY_TK error
1942                 {yyerror ("'{' expected"); RECOVER; }
1943 ;
1944
1945 /* 19.12 Production from 15: Expressions  */
1946 primary:
1947         primary_no_new_array
1948 |       array_creation_expression
1949 ;
1950
1951 primary_no_new_array:
1952         literal
1953 |       THIS_TK
1954                 { $$ = build_this ($1.location); }
1955 |       OP_TK expression CP_TK
1956                 {$$ = $2;}
1957 |       class_instance_creation_expression
1958 |       field_access
1959 |       method_invocation
1960 |       array_access
1961 |       type_literals
1962         /* Added, JDK1.1 inner classes. Documentation is wrong
1963            refering to a 'ClassName' (class_name) rule that doesn't
1964            exist. Used name: instead.  */
1965 |       name DOT_TK THIS_TK
1966                 {
1967                   tree wfl = build_wfl_node (this_identifier_node);
1968                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1969                 }
1970 |       OP_TK expression error
1971                 {yyerror ("')' expected"); RECOVER;}
1972 |       name DOT_TK error
1973                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1974 |       primitive_type DOT_TK error
1975                 {yyerror ("'class' expected" ); RECOVER;}
1976 |       VOID_TK DOT_TK error
1977                 {yyerror ("'class' expected" ); RECOVER;}
1978 ;
1979
1980 type_literals:
1981         name DOT_TK CLASS_TK
1982                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1983 |       array_type DOT_TK CLASS_TK
1984                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1985 |       primitive_type DOT_TK CLASS_TK
1986                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1987 |       VOID_TK DOT_TK CLASS_TK
1988                 {
1989                    $$ = build_incomplete_class_ref ($2.location,
1990                                                    void_type_node);
1991                 }
1992 ;
1993
1994 class_instance_creation_expression:
1995         NEW_TK class_type OP_TK argument_list CP_TK
1996                 { $$ = build_new_invocation ($2, $4); }
1997 |       NEW_TK class_type OP_TK CP_TK
1998                 { $$ = build_new_invocation ($2, NULL_TREE); }
1999 |       anonymous_class_creation
2000         /* Added, JDK1.1 inner classes, modified to use name or
2001            primary instead of primary solely which couldn't work in
2002            all situations.  */
2003 |       something_dot_new identifier OP_TK CP_TK
2004                 {
2005                   tree ctor = build_new_invocation ($2, NULL_TREE);
2006                   $$ = make_qualified_primary ($1, ctor,
2007                                                EXPR_WFL_LINECOL ($1));
2008                 }
2009 |       something_dot_new identifier OP_TK CP_TK class_body
2010 |       something_dot_new identifier OP_TK argument_list CP_TK
2011                 {
2012                   tree ctor = build_new_invocation ($2, $4);
2013                   $$ = make_qualified_primary ($1, ctor,
2014                                                EXPR_WFL_LINECOL ($1));
2015                 }
2016 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2017 |       NEW_TK error SC_TK
2018                 {yyerror ("'(' expected"); DRECOVER(new_1);}
2019 |       NEW_TK class_type error
2020                 {yyerror ("'(' expected"); RECOVER;}
2021 |       NEW_TK class_type OP_TK error
2022                 {yyerror ("')' or term expected"); RECOVER;}
2023 |       NEW_TK class_type OP_TK argument_list error
2024                 {yyerror ("')' expected"); RECOVER;}
2025 |       something_dot_new error
2026                 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2027 |       something_dot_new identifier error
2028                 {yyerror ("'(' expected"); RECOVER;}
2029 ;
2030
2031 /* Created after JDK1.1 rules originally added to
2032    class_instance_creation_expression, but modified to use
2033    'class_type' instead of 'TypeName' (type_name) which is mentioned
2034    in the documentation but doesn't exist. */
2035
2036 anonymous_class_creation:
2037         NEW_TK class_type OP_TK argument_list CP_TK
2038                 { create_anonymous_class ($1.location, $2); }
2039         class_body
2040                 {
2041                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2042                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2043
2044                   end_class_declaration (1);
2045
2046                   /* Now we can craft the new expression */
2047                   $$ = build_new_invocation (id, $4);
2048
2049                   /* Note that we can't possibly be here if
2050                      `class_type' is an interface (in which case the
2051                      anonymous class extends Object and implements
2052                      `class_type', hence its constructor can't have
2053                      arguments.) */
2054
2055                   /* Otherwise, the innerclass must feature a
2056                      constructor matching `argument_list'. Anonymous
2057                      classes are a bit special: it's impossible to
2058                      define constructor for them, hence constructors
2059                      must be generated following the hints provided by
2060                      the `new' expression. Whether a super constructor
2061                      of that nature exists or not is to be verified
2062                      later on in verify_constructor_super.
2063
2064                      It's during the expansion of a `new' statement
2065                      refering to an anonymous class that a ctor will
2066                      be generated for the anonymous class, with the
2067                      right arguments. */
2068
2069                 }
2070 |       NEW_TK class_type OP_TK CP_TK
2071                 { create_anonymous_class ($1.location, $2); }
2072         class_body
2073                 {
2074                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2075                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2076
2077                   end_class_declaration (1);
2078
2079                   /* Now we can craft the new expression. The
2080                      statement doesn't need to be remember so that a
2081                      constructor can be generated, since its signature
2082                      is already known. */
2083                   $$ = build_new_invocation (id, NULL_TREE);
2084                 }
2085 ;
2086
2087 something_dot_new:              /* Added, not part of the specs. */
2088         name DOT_TK NEW_TK
2089                 { $$ = $1; }
2090 |       primary DOT_TK NEW_TK
2091                 { $$ = $1; }
2092 ;
2093
2094 argument_list:
2095         expression
2096                 {
2097                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2098                   ctxp->formal_parameter_number = 1;
2099                 }
2100 |       argument_list C_TK expression
2101                 {
2102                   ctxp->formal_parameter_number += 1;
2103                   $$ = tree_cons (NULL_TREE, $3, $1);
2104                 }
2105 |       argument_list C_TK error
2106                 {yyerror ("Missing term"); RECOVER;}
2107 ;
2108
2109 array_creation_expression:
2110         NEW_TK primitive_type dim_exprs
2111                 { $$ = build_newarray_node ($2, $3, 0); }
2112 |       NEW_TK class_or_interface_type dim_exprs
2113                 { $$ = build_newarray_node ($2, $3, 0); }
2114 |       NEW_TK primitive_type dim_exprs dims
2115                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2116 |       NEW_TK class_or_interface_type dim_exprs dims
2117                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2118         /* Added, JDK1.1 anonymous array. Initial documentation rule
2119            modified */
2120 |       NEW_TK class_or_interface_type dims array_initializer
2121                 {
2122                   char *sig;
2123                   int osb = pop_current_osb (ctxp);
2124                   while (osb--)
2125                     obstack_grow (&temporary_obstack, "[]", 2);
2126                   obstack_1grow (&temporary_obstack, '\0');
2127                   sig = obstack_finish (&temporary_obstack);
2128                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2129                               $2, get_identifier (sig), $4);
2130                 }
2131 |       NEW_TK primitive_type dims array_initializer
2132                 {
2133                   int osb = pop_current_osb (ctxp);
2134                   tree type = $2;
2135                   while (osb--)
2136                     type = build_java_array_type (type, -1);
2137                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2138                               build_pointer_type (type), NULL_TREE, $4);
2139                 }
2140 |       NEW_TK error CSB_TK
2141                 {yyerror ("'[' expected"); DRECOVER ("]");}
2142 |       NEW_TK error OSB_TK
2143                 {yyerror ("']' expected"); RECOVER;}
2144 ;
2145
2146 dim_exprs:
2147         dim_expr
2148                 { $$ = build_tree_list (NULL_TREE, $1); }
2149 |       dim_exprs dim_expr
2150                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2151 ;
2152
2153 dim_expr:
2154         OSB_TK expression CSB_TK
2155                 {
2156                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2157                     {
2158                       $2 = build_wfl_node ($2);
2159                       TREE_TYPE ($2) = NULL_TREE;
2160                     }
2161                   EXPR_WFL_LINECOL ($2) = $1.location;
2162                   $$ = $2;
2163                 }
2164 |       OSB_TK expression error
2165                 {yyerror ("']' expected"); RECOVER;}
2166 |       OSB_TK error
2167                 {
2168                   yyerror ("Missing term");
2169                   yyerror ("']' expected");
2170                   RECOVER;
2171                 }
2172 ;
2173
2174 dims:
2175         OSB_TK CSB_TK
2176                 {
2177                   int allocate = 0;
2178                   /* If not initialized, allocate memory for the osb
2179                      numbers stack */
2180                   if (!ctxp->osb_limit)
2181                     {
2182                       allocate = ctxp->osb_limit = 32;
2183                       ctxp->osb_depth = -1;
2184                     }
2185                   /* If capacity overflown, reallocate a bigger chunk */
2186                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2187                     allocate = ctxp->osb_limit << 1;
2188
2189                   if (allocate)
2190                     {
2191                       allocate *= sizeof (int);
2192                       if (ctxp->osb_number)
2193                         ctxp->osb_number = xrealloc (ctxp->osb_number,
2194                                                      allocate);
2195                       else
2196                         ctxp->osb_number = xmalloc (allocate);
2197                     }
2198                   ctxp->osb_depth++;
2199                   CURRENT_OSB (ctxp) = 1;
2200                 }
2201 |       dims OSB_TK CSB_TK
2202                 { CURRENT_OSB (ctxp)++; }
2203 |       dims OSB_TK error
2204                 { yyerror ("']' expected"); RECOVER;}
2205 ;
2206
2207 field_access:
2208         primary DOT_TK identifier
2209                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2210                 /*  FIXME - REWRITE TO:
2211                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2212 |       SUPER_TK DOT_TK identifier
2213                 {
2214                   tree super_wfl = build_wfl_node (super_identifier_node);
2215                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
2216                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2217                 }
2218 |       SUPER_TK error
2219                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2220 ;
2221
2222 method_invocation:
2223         name OP_TK CP_TK
2224                 { $$ = build_method_invocation ($1, NULL_TREE); }
2225 |       name OP_TK argument_list CP_TK
2226                 { $$ = build_method_invocation ($1, $3); }
2227 |       primary DOT_TK identifier OP_TK CP_TK
2228                 {
2229                   if (TREE_CODE ($1) == THIS_EXPR)
2230                     $$ = build_this_super_qualified_invocation
2231                       (1, $3, NULL_TREE, 0, $2.location);
2232                   else
2233                     {
2234                       tree invok = build_method_invocation ($3, NULL_TREE);
2235                       $$ = make_qualified_primary ($1, invok, $2.location);
2236                     }
2237                 }
2238 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2239                 {
2240                   if (TREE_CODE ($1) == THIS_EXPR)
2241                     $$ = build_this_super_qualified_invocation
2242                       (1, $3, $5, 0, $2.location);
2243                   else
2244                     {
2245                       tree invok = build_method_invocation ($3, $5);
2246                       $$ = make_qualified_primary ($1, invok, $2.location);
2247                     }
2248                 }
2249 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2250                 {
2251                   $$ = build_this_super_qualified_invocation
2252                     (0, $3, NULL_TREE, $1.location, $2.location);
2253                 }
2254 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2255                 {
2256                   $$ = build_this_super_qualified_invocation
2257                     (0, $3, $5, $1.location, $2.location);
2258                 }
2259         /* Screws up thing. I let it here until I'm convinced it can
2260            be removed. FIXME
2261 |       primary DOT_TK error
2262                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2263 |       SUPER_TK DOT_TK error CP_TK
2264                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2265 |       SUPER_TK DOT_TK error DOT_TK
2266                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2267 ;
2268
2269 array_access:
2270         name OSB_TK expression CSB_TK
2271                 { $$ = build_array_ref ($2.location, $1, $3); }
2272 |       primary_no_new_array OSB_TK expression CSB_TK
2273                 { $$ = build_array_ref ($2.location, $1, $3); }
2274 |       name OSB_TK error
2275                 {
2276                   yyerror ("Missing term and ']' expected");
2277                   DRECOVER(array_access);
2278                 }
2279 |       name OSB_TK expression error
2280                 {
2281                   yyerror ("']' expected");
2282                   DRECOVER(array_access);
2283                 }
2284 |       primary_no_new_array OSB_TK error
2285                 {
2286                   yyerror ("Missing term and ']' expected");
2287                   DRECOVER(array_access);
2288                 }
2289 |       primary_no_new_array OSB_TK expression error
2290                 {
2291                   yyerror ("']' expected");
2292                   DRECOVER(array_access);
2293                 }
2294 ;
2295
2296 postfix_expression:
2297         primary
2298 |       name
2299 |       post_increment_expression
2300 |       post_decrement_expression
2301 ;
2302
2303 post_increment_expression:
2304         postfix_expression INCR_TK
2305                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2306 ;
2307
2308 post_decrement_expression:
2309         postfix_expression DECR_TK
2310                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2311 ;
2312
2313 trap_overflow_corner_case:
2314         pre_increment_expression
2315 |       pre_decrement_expression
2316 |       PLUS_TK unary_expression
2317                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2318 |       unary_expression_not_plus_minus
2319 |       PLUS_TK error
2320                 {yyerror ("Missing term"); RECOVER}
2321 ;
2322
2323 unary_expression:
2324         trap_overflow_corner_case
2325                 {
2326                   error_if_numeric_overflow ($1);
2327                   $$ = $1;
2328                 }
2329 |       MINUS_TK trap_overflow_corner_case
2330                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2331 |       MINUS_TK error
2332                 {yyerror ("Missing term"); RECOVER}
2333 ;
2334
2335 pre_increment_expression:
2336         INCR_TK unary_expression
2337                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2338 |       INCR_TK error
2339                 {yyerror ("Missing term"); RECOVER}
2340 ;
2341
2342 pre_decrement_expression:
2343         DECR_TK unary_expression
2344                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2345 |       DECR_TK error
2346                 {yyerror ("Missing term"); RECOVER}
2347 ;
2348
2349 unary_expression_not_plus_minus:
2350         postfix_expression
2351 |       NOT_TK unary_expression
2352                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2353 |       NEG_TK unary_expression
2354                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2355 |       cast_expression
2356 |       NOT_TK error
2357                 {yyerror ("Missing term"); RECOVER}
2358 |       NEG_TK error
2359                 {yyerror ("Missing term"); RECOVER}
2360 ;
2361
2362 cast_expression:                /* Error handling here is potentially weak */
2363         OP_TK primitive_type dims CP_TK unary_expression
2364                 {
2365                   tree type = $2;
2366                   int osb = pop_current_osb (ctxp);
2367                   while (osb--)
2368                     type = build_java_array_type (type, -1);
2369                   $$ = build_cast ($1.location, type, $5);
2370                 }
2371 |       OP_TK primitive_type CP_TK unary_expression
2372                 { $$ = build_cast ($1.location, $2, $4); }
2373 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2374                 { $$ = build_cast ($1.location, $2, $4); }
2375 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2376                 {
2377                   const char *ptr;
2378                   int osb = pop_current_osb (ctxp);
2379                   obstack_grow (&temporary_obstack,
2380                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2381                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2382                   while (osb--)
2383                     obstack_grow (&temporary_obstack, "[]", 2);
2384                   obstack_1grow (&temporary_obstack, '\0');
2385                   ptr = obstack_finish (&temporary_obstack);
2386                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2387                   $$ = build_cast ($1.location, $2, $5);
2388                 }
2389 |       OP_TK primitive_type OSB_TK error
2390                 {yyerror ("']' expected, invalid type expression");}
2391 |       OP_TK error
2392                 {
2393                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2394                   RECOVER;
2395                 }
2396 |       OP_TK primitive_type dims CP_TK error
2397                 {yyerror ("Missing term"); RECOVER;}
2398 |       OP_TK primitive_type CP_TK error
2399                 {yyerror ("Missing term"); RECOVER;}
2400 |       OP_TK name dims CP_TK error
2401                 {yyerror ("Missing term"); RECOVER;}
2402 ;
2403
2404 multiplicative_expression:
2405         unary_expression
2406 |       multiplicative_expression MULT_TK unary_expression
2407                 {
2408                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2409                                     $2.location, $1, $3);
2410                 }
2411 |       multiplicative_expression DIV_TK unary_expression
2412                 {
2413                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2414                                     $1, $3);
2415                 }
2416 |       multiplicative_expression REM_TK unary_expression
2417                 {
2418                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2419                                     $1, $3);
2420                 }
2421 |       multiplicative_expression MULT_TK error
2422                 {yyerror ("Missing term"); RECOVER;}
2423 |       multiplicative_expression DIV_TK error
2424                 {yyerror ("Missing term"); RECOVER;}
2425 |       multiplicative_expression REM_TK error
2426                 {yyerror ("Missing term"); RECOVER;}
2427 ;
2428
2429 additive_expression:
2430         multiplicative_expression
2431 |       additive_expression PLUS_TK multiplicative_expression
2432                 {
2433                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2434                                     $1, $3);
2435                 }
2436 |       additive_expression MINUS_TK multiplicative_expression
2437                 {
2438                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2439                                     $1, $3);
2440                 }
2441 |       additive_expression PLUS_TK error
2442                 {yyerror ("Missing term"); RECOVER;}
2443 |       additive_expression MINUS_TK error
2444                 {yyerror ("Missing term"); RECOVER;}
2445 ;
2446
2447 shift_expression:
2448         additive_expression
2449 |       shift_expression LS_TK additive_expression
2450                 {
2451                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2452                                     $1, $3);
2453                 }
2454 |       shift_expression SRS_TK additive_expression
2455                 {
2456                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2457                                     $1, $3);
2458                 }
2459 |       shift_expression ZRS_TK additive_expression
2460                 {
2461                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2462                                     $1, $3);
2463                 }
2464 |       shift_expression LS_TK error
2465                 {yyerror ("Missing term"); RECOVER;}
2466 |       shift_expression SRS_TK error
2467                 {yyerror ("Missing term"); RECOVER;}
2468 |       shift_expression ZRS_TK error
2469                 {yyerror ("Missing term"); RECOVER;}
2470 ;
2471
2472 relational_expression:
2473         shift_expression
2474 |       relational_expression LT_TK shift_expression
2475                 {
2476                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2477                                     $1, $3);
2478                 }
2479 |       relational_expression GT_TK shift_expression
2480                 {
2481                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2482                                     $1, $3);
2483                 }
2484 |       relational_expression LTE_TK shift_expression
2485                 {
2486                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2487                                     $1, $3);
2488                 }
2489 |       relational_expression GTE_TK shift_expression
2490                 {
2491                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2492                                     $1, $3);
2493                 }
2494 |       relational_expression INSTANCEOF_TK reference_type
2495                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2496 |       relational_expression LT_TK error
2497                 {yyerror ("Missing term"); RECOVER;}
2498 |       relational_expression GT_TK error
2499                 {yyerror ("Missing term"); RECOVER;}
2500 |       relational_expression LTE_TK error
2501                 {yyerror ("Missing term"); RECOVER;}
2502 |       relational_expression GTE_TK error
2503                 {yyerror ("Missing term"); RECOVER;}
2504 |       relational_expression INSTANCEOF_TK error
2505                 {yyerror ("Invalid reference type"); RECOVER;}
2506 ;
2507
2508 equality_expression:
2509         relational_expression
2510 |       equality_expression EQ_TK relational_expression
2511                 {
2512                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2513                                     $1, $3);
2514                 }
2515 |       equality_expression NEQ_TK relational_expression
2516                 {
2517                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2518                                     $1, $3);
2519                 }
2520 |       equality_expression EQ_TK error
2521                 {yyerror ("Missing term"); RECOVER;}
2522 |       equality_expression NEQ_TK error
2523                 {yyerror ("Missing term"); RECOVER;}
2524 ;
2525
2526 and_expression:
2527         equality_expression
2528 |       and_expression AND_TK equality_expression
2529                 {
2530                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2531                                     $1, $3);
2532                 }
2533 |       and_expression AND_TK error
2534                 {yyerror ("Missing term"); RECOVER;}
2535 ;
2536
2537 exclusive_or_expression:
2538         and_expression
2539 |       exclusive_or_expression XOR_TK and_expression
2540                 {
2541                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2542                                     $1, $3);
2543                 }
2544 |       exclusive_or_expression XOR_TK error
2545                 {yyerror ("Missing term"); RECOVER;}
2546 ;
2547
2548 inclusive_or_expression:
2549         exclusive_or_expression
2550 |       inclusive_or_expression OR_TK exclusive_or_expression
2551                 {
2552                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2553                                     $1, $3);
2554                 }
2555 |       inclusive_or_expression OR_TK error
2556                 {yyerror ("Missing term"); RECOVER;}
2557 ;
2558
2559 conditional_and_expression:
2560         inclusive_or_expression
2561 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2562                 {
2563                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2564                                     $1, $3);
2565                 }
2566 |       conditional_and_expression BOOL_AND_TK error
2567                 {yyerror ("Missing term"); RECOVER;}
2568 ;
2569
2570 conditional_or_expression:
2571         conditional_and_expression
2572 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2573                 {
2574                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2575                                     $1, $3);
2576                 }
2577 |       conditional_or_expression BOOL_OR_TK error
2578                 {yyerror ("Missing term"); RECOVER;}
2579 ;
2580
2581 conditional_expression:         /* Error handling here is weak */
2582         conditional_or_expression
2583 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2584                 {
2585                   $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2586                   EXPR_WFL_LINECOL ($$) = $2.location;
2587                 }
2588 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2589                 {
2590                   YYERROR_NOW;
2591                   yyerror ("Missing term");
2592                   DRECOVER (1);
2593                 }
2594 |       conditional_or_expression REL_QM_TK error
2595                 {yyerror ("Missing term"); DRECOVER (2);}
2596 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2597                 {yyerror ("Missing term"); DRECOVER (3);}
2598 ;
2599
2600 assignment_expression:
2601         conditional_expression
2602 |       assignment
2603 ;
2604
2605 assignment:
2606         left_hand_side assignment_operator assignment_expression
2607                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2608 |       left_hand_side assignment_operator error
2609                 {
2610                   YYNOT_TWICE yyerror ("Missing term");
2611                   DRECOVER (assign);
2612                 }
2613 ;
2614
2615 left_hand_side:
2616         name
2617 |       field_access
2618 |       array_access
2619 ;
2620
2621 assignment_operator:
2622         ASSIGN_ANY_TK
2623 |       ASSIGN_TK
2624 ;
2625
2626 expression:
2627         assignment_expression
2628 ;
2629
2630 constant_expression:
2631         expression
2632 ;
2633
2634 %%
2635
2636 /* Helper function to retrieve an OSB count. Should be used when the
2637    `dims:' rule is being used.  */
2638
2639 static int
2640 pop_current_osb (struct parser_ctxt *ctxp)
2641 {
2642   int to_return;
2643
2644   if (ctxp->osb_depth < 0)
2645     abort ();
2646
2647   to_return = CURRENT_OSB (ctxp);
2648   ctxp->osb_depth--;
2649
2650   return to_return;
2651 }
2652
2653 \f
2654
2655 /* This section of the code deal with save/restoring parser contexts.
2656    Add mode documentation here. FIXME */
2657
2658 /* Helper function. Create a new parser context. With
2659    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2660    context is copied, otherwise, the new context is zeroed. The newly
2661    created context becomes the current one.  */
2662
2663 static void
2664 create_new_parser_context (int copy_from_previous)
2665 {
2666   struct parser_ctxt *new;
2667
2668   new = ggc_alloc (sizeof (struct parser_ctxt));
2669   if (copy_from_previous)
2670     {
2671       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2672       /* This flag, indicating the context saves global values,
2673          should only be set by java_parser_context_save_global.  */
2674       new->saved_data_ctx = 0;
2675     }
2676   else
2677     memset (new, 0, sizeof (struct parser_ctxt));
2678
2679   new->next = ctxp;
2680   ctxp = new;
2681 }
2682
2683 /* Create a new parser context and make it the current one. */
2684
2685 void
2686 java_push_parser_context (void)
2687 {
2688   create_new_parser_context (0);
2689 }
2690
2691 void
2692 java_pop_parser_context (int generate)
2693 {
2694   tree current;
2695   struct parser_ctxt *toFree, *next;
2696
2697   if (!ctxp)
2698     return;
2699
2700   toFree = ctxp;
2701   next = ctxp->next;
2702   if (next)
2703     {
2704       input_line = ctxp->lineno;
2705       current_class = ctxp->class_type;
2706     }
2707
2708   /* If the old and new lexers differ, then free the old one.  */
2709   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2710     java_destroy_lexer (ctxp->lexer);
2711
2712   /* Set the single import class file flag to 0 for the current list
2713      of imported things */
2714   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2715     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2716
2717   /* And restore those of the previous context */
2718   if ((ctxp = next))            /* Assignment is really meant here */
2719     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2720       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2721
2722   /* If we pushed a context to parse a class intended to be generated,
2723      we keep it so we can remember the class. What we could actually
2724      do is to just update a list of class names.  */
2725   if (generate)
2726     {
2727       toFree->next = ctxp_for_generation;
2728       ctxp_for_generation = toFree;
2729     }
2730 }
2731
2732 /* Create a parser context for the use of saving some global
2733    variables.  */
2734
2735 void
2736 java_parser_context_save_global (void)
2737 {
2738   if (!ctxp)
2739     {
2740       java_push_parser_context ();
2741       ctxp->saved_data_ctx = 1;
2742     }
2743
2744   /* If this context already stores data, create a new one suitable
2745      for data storage. */
2746   else if (ctxp->saved_data)
2747     {
2748       create_new_parser_context (1);
2749       ctxp->saved_data_ctx = 1;
2750     }
2751
2752   ctxp->lineno = input_line;
2753   ctxp->class_type = current_class;
2754   ctxp->filename = input_filename;
2755   ctxp->function_decl = current_function_decl;
2756   ctxp->saved_data = 1;
2757 }
2758
2759 /* Restore some global variables from the previous context. Make the
2760    previous context the current one.  */
2761
2762 void
2763 java_parser_context_restore_global (void)
2764 {
2765   input_line = ctxp->lineno;
2766   current_class = ctxp->class_type;
2767   input_filename = ctxp->filename;
2768   if (wfl_operator)
2769     {
2770       tree s;
2771       BUILD_FILENAME_IDENTIFIER_NODE (s, input_filename);
2772       EXPR_WFL_FILENAME_NODE (wfl_operator) = s;
2773     }
2774   current_function_decl = ctxp->function_decl;
2775   ctxp->saved_data = 0;
2776   if (ctxp->saved_data_ctx)
2777     java_pop_parser_context (0);
2778 }
2779
2780 /* Suspend vital data for the current class/function being parsed so
2781    that an other class can be parsed. Used to let local/anonymous
2782    classes be parsed.  */
2783
2784 static void
2785 java_parser_context_suspend (void)
2786 {
2787   /* This makes debugging through java_debug_context easier */
2788   static const char *const name = "<inner buffer context>";
2789
2790   /* Duplicate the previous context, use it to save the globals we're
2791      interested in */
2792   create_new_parser_context (1);
2793   ctxp->function_decl = current_function_decl;
2794   ctxp->class_type = current_class;
2795
2796   /* Then create a new context which inherits all data from the
2797      previous one. This will be the new current context  */
2798   create_new_parser_context (1);
2799
2800   /* Help debugging */
2801   ctxp->next->filename = name;
2802 }
2803
2804 /* Resume vital data for the current class/function being parsed so
2805    that an other class can be parsed. Used to let local/anonymous
2806    classes be parsed.  The trick is the data storing file position
2807    informations must be restored to their current value, so parsing
2808    can resume as if no context was ever saved. */
2809
2810 static void
2811 java_parser_context_resume (void)
2812 {
2813   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2814   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2815   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2816
2817   /* We need to inherit the list of classes to complete/generate */
2818   restored->classd_list = old->classd_list;
2819   restored->class_list = old->class_list;
2820
2821   /* Restore the current class and function from the saver */
2822   current_class = saver->class_type;
2823   current_function_decl = saver->function_decl;
2824
2825   /* Retrieve the restored context */
2826   ctxp = restored;
2827
2828   /* Re-installed the data for the parsing to carry on */
2829   memcpy (&ctxp->marker_begining, &old->marker_begining,
2830           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2831 }
2832
2833 /* Add a new anchor node to which all statement(s) initializing static
2834    and non static initialized upon declaration field(s) will be
2835    linked.  */
2836
2837 static void
2838 java_parser_context_push_initialized_field (void)
2839 {
2840   tree node;
2841
2842   node = build_tree_list (NULL_TREE, NULL_TREE);
2843   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2844   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2845
2846   node = build_tree_list (NULL_TREE, NULL_TREE);
2847   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2848   CPC_INITIALIZER_LIST (ctxp) = node;
2849
2850   node = build_tree_list (NULL_TREE, NULL_TREE);
2851   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2852   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2853 }
2854
2855 /* Pop the lists of initialized field. If this lists aren't empty,
2856    remember them so we can use it to create and populate the finit$
2857    or <clinit> functions. */
2858
2859 static void
2860 java_parser_context_pop_initialized_field (void)
2861 {
2862   tree stmts;
2863   tree class_type = TREE_TYPE (GET_CPC ());
2864
2865   if (CPC_INITIALIZER_LIST (ctxp))
2866     {
2867       stmts = CPC_INITIALIZER_STMT (ctxp);
2868       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2869       if (stmts && !java_error_count)
2870         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2871     }
2872
2873   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2874     {
2875       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2876       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2877         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2878       /* Keep initialization in order to enforce 8.5 */
2879       if (stmts && !java_error_count)
2880         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2881     }
2882
2883   /* JDK 1.1 instance initializers */
2884   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2885     {
2886       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2887       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2888         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2889       if (stmts && !java_error_count)
2890         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2891     }
2892 }
2893
2894 static tree
2895 reorder_static_initialized (tree list)
2896 {
2897   /* We have to keep things in order. The alias initializer have to
2898      come first, then the initialized regular field, in reverse to
2899      keep them in lexical order. */
2900   tree marker, previous = NULL_TREE;
2901   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2902     if (TREE_CODE (marker) == TREE_LIST
2903         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2904       break;
2905
2906   /* No static initialized, the list is fine as is */
2907   if (!previous)
2908     list = TREE_CHAIN (marker);
2909
2910   /* No marker? reverse the whole list */
2911   else if (!marker)
2912     list = nreverse (list);
2913
2914   /* Otherwise, reverse what's after the marker and the new reordered
2915      sublist will replace the marker. */
2916   else
2917     {
2918       TREE_CHAIN (previous) = NULL_TREE;
2919       list = nreverse (list);
2920       list = chainon (TREE_CHAIN (marker), list);
2921     }
2922   return list;
2923 }
2924
2925 /* Helper functions to dump the parser context stack.  */
2926
2927 #define TAB_CONTEXT(C) \
2928   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2929
2930 static void
2931 java_debug_context_do (int tab)
2932 {
2933   struct parser_ctxt *copy = ctxp;
2934   while (copy)
2935     {
2936       TAB_CONTEXT (tab);
2937       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2938       TAB_CONTEXT (tab);
2939       fprintf (stderr, "filename: %s\n", copy->filename);
2940       TAB_CONTEXT (tab);
2941       fprintf (stderr, "lineno: %d\n", copy->lineno);
2942       TAB_CONTEXT (tab);
2943       fprintf (stderr, "package: %s\n",
2944                (copy->package ?
2945                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2946       TAB_CONTEXT (tab);
2947       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2948       TAB_CONTEXT (tab);
2949       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2950       copy = copy->next;
2951       tab += 2;
2952     }
2953 }
2954
2955 /* Dump the stacked up parser contexts. Intended to be called from a
2956    debugger.  */
2957
2958 void
2959 java_debug_context (void)
2960 {
2961   java_debug_context_do (0);
2962 }
2963
2964 \f
2965
2966 /* Flag for the error report routine to issue the error the first time
2967    it's called (overriding the default behavior which is to drop the
2968    first invocation and honor the second one, taking advantage of a
2969    richer context.  */
2970 static int force_error = 0;
2971
2972 /* Reporting an constructor invocation error.  */
2973 static void
2974 parse_ctor_invocation_error (void)
2975 {
2976   if (DECL_CONSTRUCTOR_P (current_function_decl))
2977     yyerror ("Constructor invocation must be first thing in a constructor");
2978   else
2979     yyerror ("Only constructors can invoke constructors");
2980 }
2981
2982 /* Reporting JDK1.1 features not implemented.  */
2983
2984 static tree
2985 parse_jdk1_1_error (const char *msg)
2986 {
2987   sorry (": `%s' JDK1.1(TM) feature", msg);
2988   java_error_count++;
2989   return empty_stmt_node;
2990 }
2991
2992 static int do_warning = 0;
2993
2994 void
2995 yyerror (const char *msg)
2996 {
2997   static java_lc elc;
2998   static int  prev_lineno;
2999   static const char *prev_msg;
3000
3001   int save_lineno;
3002   char *remainder, *code_from_source;
3003
3004   if (!force_error && prev_lineno == input_line)
3005     return;
3006
3007   /* Save current error location but report latter, when the context is
3008      richer.  */
3009   if (ctxp->java_error_flag == 0)
3010     {
3011       ctxp->java_error_flag = 1;
3012       elc = ctxp->elc;
3013       /* Do something to use the previous line if we're reaching the
3014          end of the file... */
3015 #ifdef VERBOSE_SKELETON
3016       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3017 #endif
3018       return;
3019     }
3020
3021   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3022   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3023     return;
3024
3025   ctxp->java_error_flag = 0;
3026   if (do_warning)
3027     java_warning_count++;
3028   else
3029     java_error_count++;
3030
3031   if (elc.col == 0 && msg && msg[1] == ';')
3032     {
3033       elc.col  = ctxp->p_line->char_col-1;
3034       elc.line = ctxp->p_line->lineno;
3035     }
3036
3037   save_lineno = input_line;
3038   prev_lineno = input_line = elc.line;
3039   prev_msg = msg;
3040
3041   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3042   obstack_grow0 (&temporary_obstack,
3043                  code_from_source, strlen (code_from_source));
3044   remainder = obstack_finish (&temporary_obstack);
3045   if (do_warning)
3046     warning ("%s.\n%s", msg, remainder);
3047   else
3048     error ("%s.\n%s", msg, remainder);
3049
3050   /* This allow us to cheaply avoid an extra 'Invalid expression
3051      statement' error report when errors have been already reported on
3052      the same line. This occurs when we report an error but don't have
3053      a synchronization point other than ';', which
3054      expression_statement is the only one to take care of.  */
3055   ctxp->prevent_ese = input_line = save_lineno;
3056 }
3057
3058 static void
3059 issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
3060 {
3061   const char *saved, *saved_input_filename;
3062   char buffer [4096];
3063   vsprintf (buffer, msg, ap);
3064   force_error = 1;
3065
3066   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3067   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3068                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3069
3070   /* We have a CL, that's a good reason for using it if it contains data */
3071   saved = ctxp->filename;
3072   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3073     ctxp->filename = EXPR_WFL_FILENAME (cl);
3074   saved_input_filename = input_filename;
3075   input_filename = ctxp->filename;
3076   java_error (NULL);
3077   java_error (buffer);
3078   ctxp->filename = saved;
3079   input_filename = saved_input_filename;
3080   force_error = 0;
3081 }
3082
3083 /* Issue an error message at a current source line CL */
3084
3085 void
3086 parse_error_context (tree cl, const char *msg, ...)
3087 {
3088   va_list ap;
3089   va_start (ap, msg);
3090   issue_warning_error_from_context (cl, msg, ap);
3091   va_end (ap);
3092 }
3093
3094 /* Issue a warning at a current source line CL */
3095
3096 static void
3097 parse_warning_context (tree cl, const char *msg, ...)
3098 {
3099   va_list ap;
3100   va_start (ap, msg);
3101
3102   force_error = do_warning = 1;
3103   issue_warning_error_from_context (cl, msg, ap);
3104   do_warning = force_error = 0;
3105   va_end (ap);
3106 }
3107
3108 static tree
3109 find_expr_with_wfl (tree node)
3110 {
3111   while (node)
3112     {
3113       char code;
3114       tree to_return;
3115
3116       switch (TREE_CODE (node))
3117         {
3118         case BLOCK:
3119           node = BLOCK_EXPR_BODY (node);
3120           continue;
3121
3122         case COMPOUND_EXPR:
3123           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3124           if (to_return)
3125             return to_return;
3126           node = TREE_OPERAND (node, 1);
3127           continue;
3128
3129         case LOOP_EXPR:
3130           node = TREE_OPERAND (node, 0);
3131           continue;
3132
3133         case LABELED_BLOCK_EXPR:
3134           node = TREE_OPERAND (node, 1);
3135           continue;
3136
3137         default:
3138           code = TREE_CODE_CLASS (TREE_CODE (node));
3139           if (((code == '1') || (code == '2') || (code == 'e'))
3140               && EXPR_WFL_LINECOL (node))
3141             return node;
3142           return NULL_TREE;
3143         }
3144     }
3145   return NULL_TREE;
3146 }
3147
3148 /* Issue a missing return statement error. Uses METHOD to figure the
3149    last line of the method the error occurs in.  */
3150
3151 static void
3152 missing_return_error (tree method)
3153 {
3154   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3155   parse_error_context (wfl_operator, "Missing return statement");
3156 }
3157
3158 /* Issue an unreachable statement error. From NODE, find the next
3159    statement to report appropriately.  */
3160 static void
3161 unreachable_stmt_error (tree node)
3162 {
3163   /* Browse node to find the next expression node that has a WFL. Use
3164      the location to report the error */
3165   if (TREE_CODE (node) == COMPOUND_EXPR)
3166     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3167   else
3168     node = find_expr_with_wfl (node);
3169
3170   if (node)
3171     {
3172       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3173       parse_error_context (wfl_operator, "Unreachable statement");
3174     }
3175   else
3176     abort ();
3177 }
3178
3179 static int
3180 not_accessible_field_error (tree wfl, tree decl)
3181 {
3182   parse_error_context
3183     (wfl, "Can't access %s field `%s.%s' from `%s'",
3184      java_accstring_lookup (get_access_flags_from_decl (decl)),
3185      GET_TYPE_NAME (DECL_CONTEXT (decl)),
3186      IDENTIFIER_POINTER (DECL_NAME (decl)),
3187      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3188   return 1;
3189 }
3190
3191 int
3192 java_report_errors (void)
3193 {
3194   if (java_error_count)
3195     fprintf (stderr, "%d error%s",
3196              java_error_count, (java_error_count == 1 ? "" : "s"));
3197   if (java_warning_count)
3198     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3199              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3200   if (java_error_count || java_warning_count)
3201     putc ('\n', stderr);
3202   return java_error_count;
3203 }
3204
3205 static char *
3206 java_accstring_lookup (int flags)
3207 {
3208   static char buffer [80];
3209 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3210
3211   /* Access modifier looked-up first for easier report on forbidden
3212      access. */
3213   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3214   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3215   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3216   if (flags & ACC_STATIC) COPY_RETURN ("static");
3217   if (flags & ACC_FINAL) COPY_RETURN ("final");
3218   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3219   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3220   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3221   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3222   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3223   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3224
3225   buffer [0] = '\0';
3226   return buffer;
3227 #undef COPY_RETURN
3228 }
3229
3230 /* Issuing error messages upon redefinition of classes, interfaces or
3231    variables. */
3232
3233 static void
3234 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3235 {
3236   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3237                        context, IDENTIFIER_POINTER (id),
3238                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3239   /* Here we should point out where its redefined. It's a unicode. FIXME */
3240 }
3241
3242 static void
3243 variable_redefinition_error (tree context, tree name, tree type, int line)
3244 {
3245   const char *type_name;
3246
3247   /* Figure a proper name for type. We might haven't resolved it */
3248   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3249     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3250   else
3251     type_name = lang_printable_name (type, 0);
3252
3253   parse_error_context (context,
3254                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3255                        IDENTIFIER_POINTER (name),
3256                        type_name, IDENTIFIER_POINTER (name), line);
3257 }
3258
3259 /* If ANAME is terminated with `[]', it indicates an array. This
3260    function returns the number of `[]' found and if this number is
3261    greater than zero, it extracts the array type name and places it in
3262    the node pointed to by TRIMMED unless TRIMMED is null.  */
3263
3264 static int
3265 build_type_name_from_array_name (tree aname, tree *trimmed)
3266 {
3267   const char *name = IDENTIFIER_POINTER (aname);
3268   int len = IDENTIFIER_LENGTH (aname);
3269   int array_dims;
3270
3271   STRING_STRIP_BRACKETS (name, len, array_dims);
3272
3273   if (array_dims && trimmed)
3274     *trimmed = get_identifier_with_length (name, len);
3275
3276   return array_dims;
3277 }
3278
3279 static tree
3280 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3281 {
3282   int more_dims = 0;
3283
3284   /* Eventually get more dims */
3285   more_dims = build_type_name_from_array_name (name, &name);
3286
3287   /* If we have, then craft a new type for this variable */
3288   if (more_dims)
3289     {
3290       tree save = type;
3291
3292       /* If we have a pointer, use its type */
3293       if (TREE_CODE (type) == POINTER_TYPE)
3294         type = TREE_TYPE (type);
3295
3296       /* Building the first dimension of a primitive type uses this
3297          function */
3298       if (JPRIMITIVE_TYPE_P (type))
3299         {
3300           type = build_java_array_type (type, -1);
3301           more_dims--;
3302         }
3303       /* Otherwise, if we have a WFL for this type, use it (the type
3304          is already an array on an unresolved type, and we just keep
3305          on adding dimensions) */
3306       else if (type_wfl)
3307         {
3308           type = type_wfl;
3309           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3310                                                         NULL);
3311         }
3312
3313       /* Add all the dimensions */
3314       while (more_dims--)
3315         type = build_unresolved_array_type (type);
3316
3317       /* The type may have been incomplete in the first place */
3318       if (type_wfl)
3319         type = obtain_incomplete_type (type);
3320     }
3321
3322   if (ret_name)
3323     *ret_name = name;
3324   return type;
3325 }
3326
3327 /* Build something that the type identifier resolver will identify as
3328    being an array to an unresolved type. TYPE_WFL is a WFL on a
3329    identifier. */
3330
3331 static tree
3332 build_unresolved_array_type (tree type_or_wfl)
3333 {
3334   const char *ptr;
3335   tree wfl;
3336
3337   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3338      just create a array type */
3339   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3340     return build_java_array_type (type_or_wfl, -1);
3341
3342   obstack_grow (&temporary_obstack,
3343                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3344                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3345   obstack_grow0 (&temporary_obstack, "[]", 2);
3346   ptr = obstack_finish (&temporary_obstack);
3347   wfl = build_expr_wfl (get_identifier (ptr),
3348                         EXPR_WFL_FILENAME (type_or_wfl),
3349                         EXPR_WFL_LINENO (type_or_wfl),
3350                         EXPR_WFL_COLNO (type_or_wfl));
3351   /* Re-install the existing qualifications so that the type can be
3352      resolved properly. */
3353   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3354   return wfl;
3355 }
3356
3357 static void
3358 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3359 {
3360   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3361     parse_error_context (wfl, "Interface `%s' repeated",
3362                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3363 }
3364
3365 /* Bulk of common class/interface checks. Return 1 if an error was
3366    encountered. TAG is 0 for a class, 1 for an interface.  */
3367
3368 static int
3369 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3370                                 tree qualified_name, tree decl, tree cl)
3371 {
3372   tree node;
3373   int sca = 0;                  /* Static class allowed */
3374   int icaf = 0;                 /* Inner class allowed flags */
3375   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3376
3377   if (!quiet_flag)
3378     fprintf (stderr, " %s%s %s",
3379              (CPC_INNER_P () ? "inner" : ""),
3380              (is_interface ? "interface" : "class"),
3381              IDENTIFIER_POINTER (qualified_name));
3382
3383   /* Scope of an interface/class type name:
3384        - Can't be imported by a single type import
3385        - Can't already exists in the package */
3386   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3387       && (node = find_name_in_single_imports (raw_name))
3388       && !CPC_INNER_P ())
3389     {
3390       parse_error_context
3391         (cl, "%s name `%s' clashes with imported type `%s'",
3392          (is_interface ? "Interface" : "Class"),
3393          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3394       return 1;
3395     }
3396   if (decl && CLASS_COMPLETE_P (decl))
3397     {
3398       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3399                                    qualified_name, decl, cl);
3400       return 1;
3401     }
3402
3403   if (check_inner_class_redefinition (raw_name, cl))
3404     return 1;
3405
3406   /* If public, file name should match class/interface name, except
3407      when dealing with an inner class */
3408   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3409     {
3410       const char *f;
3411
3412       for (f = &input_filename [strlen (input_filename)];
3413            f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3414            f--)
3415         ;
3416       if (IS_DIR_SEPARATOR (f[0]))
3417         f++;
3418       if (strncmp (IDENTIFIER_POINTER (raw_name),
3419                    f , IDENTIFIER_LENGTH (raw_name)) ||
3420           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3421         parse_error_context
3422           (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3423                              (is_interface ? "interface" : "class"),
3424                              IDENTIFIER_POINTER (qualified_name),
3425                              IDENTIFIER_POINTER (raw_name));
3426     }
3427
3428   /* Static classes can be declared only in top level classes. Note:
3429      once static, a inner class is a top level class. */
3430   if (flags & ACC_STATIC)
3431     {
3432       /* Catch the specific error of declaring an class inner class
3433          with no toplevel enclosing class. Prevent check_modifiers from
3434          complaining a second time */
3435       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3436         {
3437           parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3438                                IDENTIFIER_POINTER (qualified_name));
3439           sca = ACC_STATIC;
3440         }
3441       /* Else, in the context of a top-level class declaration, let
3442          `check_modifiers' do its job, otherwise, give it a go */
3443       else
3444         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3445     }
3446
3447   /* Inner classes can be declared private or protected
3448      within their enclosing classes. */
3449   if (CPC_INNER_P ())
3450     {
3451       /* A class which is local to a block can't be public, private,
3452          protected or static. But it is created final, so allow this
3453          one. */
3454       if (current_function_decl)
3455         icaf = sca = uaaf = ACC_FINAL;
3456       else
3457         {
3458           check_modifiers_consistency (flags);
3459           icaf = ACC_PROTECTED;
3460           if (! CLASS_INTERFACE (GET_CPC ()))
3461             icaf |= ACC_PRIVATE;
3462         }
3463     }
3464
3465   if (is_interface)
3466     {
3467       if (CPC_INNER_P ())
3468         uaaf = INTERFACE_INNER_MODIFIERS;
3469       else
3470         uaaf = INTERFACE_MODIFIERS;
3471
3472       check_modifiers ("Illegal modifier `%s' for interface declaration",
3473                        flags, uaaf);
3474     }
3475   else
3476     check_modifiers ((current_function_decl ?
3477                       "Illegal modifier `%s' for local class declaration" :
3478                       "Illegal modifier `%s' for class declaration"),
3479                      flags, uaaf|sca|icaf);
3480   return 0;
3481 }
3482
3483 /* Construct a nested class name.  If the final component starts with
3484    a digit, return true.  Otherwise return false.  */
3485 static int
3486 make_nested_class_name (tree cpc_list)
3487 {
3488   tree name;
3489
3490   if (!cpc_list)
3491     return 0;
3492
3493   make_nested_class_name (TREE_CHAIN (cpc_list));
3494
3495   /* Pick the qualified name when dealing with the first upmost
3496      enclosing class */
3497   name = (TREE_CHAIN (cpc_list)
3498           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3499   obstack_grow (&temporary_obstack,
3500                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3501   obstack_1grow (&temporary_obstack, '$');
3502
3503   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3504 }
3505
3506 /* Can't redefine a class already defined in an earlier scope. */
3507
3508 static int
3509 check_inner_class_redefinition (tree raw_name, tree cl)
3510 {
3511   tree scope_list;
3512
3513   for (scope_list = GET_CPC_LIST (); scope_list;
3514        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3515     if (raw_name == GET_CPC_UN_NODE (scope_list))
3516       {
3517         parse_error_context
3518           (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",
3519            IDENTIFIER_POINTER (raw_name));
3520         return 1;
3521       }
3522   return 0;
3523 }
3524
3525 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3526    we remember ENCLOSING and SUPER.  */
3527
3528 static tree
3529 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3530                      tree *super, tree class_type)
3531 {
3532   tree local_enclosing = *enclosing;
3533   tree local_super = NULL_TREE;
3534
3535   while (local_enclosing)
3536     {
3537       tree intermediate, decl;
3538
3539       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3540         local_enclosing;
3541
3542       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3543         return decl;
3544
3545       intermediate = local_enclosing;
3546       /* Explore enclosing contexts. */
3547       while (INNER_CLASS_DECL_P (intermediate))
3548         {
3549           intermediate = DECL_CONTEXT (intermediate);
3550           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3551             return decl;
3552         }
3553
3554       /* Now go to the upper classes, bail out if necessary.  We will
3555          analyze the returned SUPER and act accordingly (see
3556          do_resolve_class).  */
3557       if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3558           || TREE_TYPE (local_enclosing) == void_type_node)
3559         {
3560           parse_error_context (cl, "Qualifier must be a reference");
3561           local_enclosing = NULL_TREE;
3562           break;
3563         }
3564       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3565       if (!local_super || local_super == object_type_node)
3566         break;
3567
3568       if (TREE_CODE (local_super) == POINTER_TYPE)
3569         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3570       else
3571         local_super = TYPE_NAME (local_super);
3572
3573       /* We may not have checked for circular inheritance yet, so do so
3574          here to prevent an infinite loop. */
3575       if (htab_find (circularity_hash, local_super) != NULL)
3576         {
3577           if (!cl)
3578             cl = lookup_cl (local_enclosing);
3579
3580           parse_error_context
3581             (cl, "Cyclic inheritance involving %s",
3582              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3583           local_enclosing = NULL_TREE;
3584         }
3585       else
3586         local_enclosing = local_super;
3587     }
3588
3589   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3590   *super = local_super;
3591   *enclosing = local_enclosing;
3592
3593   return NULL_TREE;
3594 }
3595
3596 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3597    qualified. */
3598
3599 static tree
3600 find_as_inner_class (tree enclosing, tree name, tree cl)
3601 {
3602   tree qual, to_return;
3603   if (!enclosing)
3604     return NULL_TREE;
3605
3606   name = TYPE_NAME (name);
3607
3608   /* First search: within the scope of `enclosing', search for name */
3609   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3610     qual = EXPR_WFL_QUALIFICATION (cl);
3611   else if (cl)
3612     qual = build_tree_list (cl, NULL_TREE);
3613   else
3614     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3615
3616   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3617     return to_return;
3618
3619   /* We're dealing with a qualified name. Try to resolve thing until
3620      we get something that is an enclosing class. */
3621   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3622     {
3623       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3624
3625       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3626            qual = TREE_CHAIN (qual))
3627         {
3628           acc = merge_qualified_name (acc,
3629                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3630           BUILD_PTR_FROM_NAME (ptr, acc);
3631           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3632         }
3633
3634       /* A NULL qual and a decl means that the search ended
3635          successfully?!? We have to do something then. FIXME */
3636
3637       if (decl)
3638         enclosing = decl;
3639       else
3640         qual = EXPR_WFL_QUALIFICATION (cl);
3641     }
3642   /* Otherwise, create a qual for the other part of the resolution. */
3643   else
3644     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3645
3646   return find_as_inner_class_do (qual, enclosing);
3647 }
3648
3649 /* We go inside the list of sub classes and try to find a way
3650    through. */
3651
3652 static tree
3653 find_as_inner_class_do (tree qual, tree enclosing)
3654 {
3655   if (!qual)
3656     return NULL_TREE;
3657
3658   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3659     {
3660       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3661       tree next_enclosing = NULL_TREE;
3662       tree inner_list;
3663
3664       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3665            inner_list; inner_list = TREE_CHAIN (inner_list))
3666         {
3667           if (TREE_VALUE (inner_list) == name_to_match)
3668             {
3669               next_enclosing = TREE_PURPOSE (inner_list);
3670               break;
3671             }
3672         }
3673       enclosing = next_enclosing;
3674     }
3675
3676   return (!qual && enclosing ? enclosing : NULL_TREE);
3677 }
3678
3679 /* Reach all inner classes and tie their unqualified name to a
3680    DECL. */
3681
3682 static void
3683 set_nested_class_simple_name_value (tree outer, int set)
3684 {
3685   tree l;
3686
3687   for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
3688     IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
3689                                                 TREE_PURPOSE (l) : NULL_TREE);
3690 }
3691
3692 static void
3693 link_nested_class_to_enclosing (void)
3694 {
3695   if (GET_ENCLOSING_CPC ())
3696     {
3697       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3698       DECL_INNER_CLASS_LIST (enclosing) =
3699         tree_cons (GET_CPC (), GET_CPC_UN (),
3700                    DECL_INNER_CLASS_LIST (enclosing));
3701     }
3702 }
3703
3704 static tree
3705 maybe_make_nested_class_name (tree name)
3706 {
3707   tree id = NULL_TREE;
3708
3709   if (CPC_INNER_P ())
3710     {
3711       /* If we're in a function, we must append a number to create the
3712          nested class name.  However, we don't do this if the class we
3713          are constructing is anonymous, because in that case we'll
3714          already have a number as the class name.  */
3715       if (! make_nested_class_name (GET_CPC_LIST ())
3716           && current_function_decl != NULL_TREE
3717           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3718         {
3719           char buf[10];
3720           sprintf (buf, "%d", anonymous_class_counter);
3721           ++anonymous_class_counter;
3722           obstack_grow (&temporary_obstack, buf, strlen (buf));
3723           obstack_1grow (&temporary_obstack, '$');
3724         }
3725       obstack_grow0 (&temporary_obstack,
3726                      IDENTIFIER_POINTER (name),
3727                      IDENTIFIER_LENGTH (name));
3728       id = get_identifier (obstack_finish (&temporary_obstack));
3729       if (ctxp->package)
3730         QUALIFIED_P (id) = 1;
3731     }
3732   return id;
3733 }
3734
3735 /* If DECL is NULL, create and push a new DECL, record the current
3736    line CL and do other maintenance things.  */
3737
3738 static tree
3739 maybe_create_class_interface_decl (tree decl, tree raw_name,
3740                                    tree qualified_name, tree cl)
3741 {
3742   if (!decl)
3743     decl = push_class (make_class (), qualified_name);
3744
3745   /* Take care of the file and line business */
3746   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3747   /* If we're emitting xrefs, store the line/col number information */
3748   if (flag_emit_xref)
3749     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3750   else
3751     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3752   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3753   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3754   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3755     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3756
3757   PUSH_CPC (decl, raw_name);
3758   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3759
3760   /* Link the declaration to the already seen ones */
3761   TREE_CHAIN (decl) = ctxp->class_list;
3762   ctxp->class_list = decl;
3763
3764   /* Create a new nodes in the global lists */
3765   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3766   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3767
3768   /* Install a new dependency list element */
3769   create_jdep_list (ctxp);
3770
3771   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3772                           IDENTIFIER_POINTER (qualified_name)));
3773   return decl;
3774 }
3775
3776 static void
3777 add_superinterfaces (tree decl, tree interface_list)
3778 {
3779   tree node;
3780   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3781      takes care of ensuring that:
3782        - This is an accessible interface type,
3783        - Circularity detection.
3784    parser_add_interface is then called. If present but not defined,
3785    the check operation is delayed until the super interface gets
3786    defined.  */
3787   for (node = interface_list; node; node = TREE_CHAIN (node))
3788     {
3789       tree current = TREE_PURPOSE (node);
3790       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3791       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3792         {
3793           if (!parser_check_super_interface (idecl, decl, current))
3794             parser_add_interface (decl, idecl, current);
3795         }
3796       else
3797         register_incomplete_type (JDEP_INTERFACE,
3798                                   current, decl, NULL_TREE);
3799     }
3800 }
3801
3802 /* Create an interface in pass1 and return its decl. Return the
3803    interface's decl in pass 2.  */
3804
3805 static tree
3806 create_interface (int flags, tree id, tree super)
3807 {
3808   tree raw_name = EXPR_WFL_NODE (id);
3809   tree q_name = parser_qualified_classname (raw_name);
3810   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3811
3812   /* Certain syntax errors are making SUPER be like ID. Avoid this
3813      case. */
3814   if (ctxp->class_err && id == super)
3815     super = NULL;
3816
3817   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3818
3819   /* Basic checks: scope, redefinition, modifiers */
3820   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3821     {
3822       PUSH_ERROR ();
3823       return NULL_TREE;
3824     }
3825
3826   /* Suspend the current parsing context if we're parsing an inner
3827      interface */
3828   if (CPC_INNER_P ())
3829     {
3830       java_parser_context_suspend ();
3831       /* Interface members are public. */
3832       if (CLASS_INTERFACE (GET_CPC ()))
3833         flags |= ACC_PUBLIC;
3834     }
3835
3836   /* Push a new context for (static) initialized upon declaration fields */
3837   java_parser_context_push_initialized_field ();
3838
3839   /* Interface modifiers check
3840        - public/abstract allowed (already done at that point)
3841        - abstract is obsolete (comes first, it's a warning, or should be)
3842        - Can't use twice the same (checked in the modifier rule) */
3843   if ((flags & ACC_ABSTRACT) && flag_redundant)
3844     parse_warning_context
3845       (MODIFIER_WFL (ABSTRACT_TK),
3846        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3847
3848   /* Create a new decl if DECL is NULL, otherwise fix it */
3849   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3850
3851   /* Set super info and mark the class a complete */
3852   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3853                   object_type_node, ctxp->interface_number);
3854   ctxp->interface_number = 0;
3855   CLASS_COMPLETE_P (decl) = 1;
3856   add_superinterfaces (decl, super);
3857
3858   /* Eventually sets the @deprecated tag flag */
3859   CHECK_DEPRECATED (decl);
3860
3861   return decl;
3862 }
3863
3864 /* Patch anonymous class CLASS, by either extending or implementing
3865    DEP.  */
3866
3867 static void
3868 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
3869 {
3870   tree class = TREE_TYPE (class_decl);
3871   tree type =  TREE_TYPE (type_decl);
3872   tree binfo = TYPE_BINFO (class);
3873
3874   /* If it's an interface, implement it */
3875   if (CLASS_INTERFACE (type_decl))
3876     {
3877       tree s_binfo;
3878       int length;
3879
3880       if (parser_check_super_interface (type_decl, class_decl, wfl))
3881         return;
3882
3883       s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3884       length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3885       TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3886       TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3887       /* And add the interface */
3888       parser_add_interface (class_decl, type_decl, wfl);
3889     }
3890   /* Otherwise, it's a type we want to extend */
3891   else
3892     {
3893       if (parser_check_super (type_decl, class_decl, wfl))
3894         return;
3895       BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3896     }
3897 }
3898
3899 static tree
3900 create_anonymous_class (int location, tree type_name)
3901 {
3902   char buffer [80];
3903   tree super = NULL_TREE, itf = NULL_TREE;
3904   tree id, type_decl, class;
3905
3906   /* The unqualified name of the anonymous class. It's just a number. */
3907   sprintf (buffer, "%d", anonymous_class_counter++);
3908   id = build_wfl_node (get_identifier (buffer));
3909   EXPR_WFL_LINECOL (id) = location;
3910
3911   /* We know about the type to extend/implement. We go ahead */
3912   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3913     {
3914       /* Create a class which either implements on extends the designated
3915          class. The class bears an inaccessible name. */
3916       if (CLASS_INTERFACE (type_decl))
3917         {
3918           /* It's OK to modify it here. It's been already used and
3919              shouldn't be reused */
3920           ctxp->interface_number = 1;
3921           /* Interfaces should presented as a list of WFLs */
3922           itf = build_tree_list (type_name, NULL_TREE);
3923         }
3924       else
3925         super = type_name;
3926     }
3927
3928   class = create_class (ACC_FINAL, id, super, itf);
3929
3930   /* We didn't know anything about the stuff. We register a dependence. */
3931   if (!type_decl)
3932     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3933
3934   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3935   return class;
3936 }
3937
3938 /* Create a class in pass1 and return its decl. Return class
3939    interface's decl in pass 2.  */
3940
3941 static tree
3942 create_class (int flags, tree id, tree super, tree interfaces)
3943 {
3944   tree raw_name = EXPR_WFL_NODE (id);
3945   tree class_id, decl;
3946   tree super_decl_type;
3947
3948   /* Certain syntax errors are making SUPER be like ID. Avoid this
3949      case. */
3950   if (ctxp->class_err && id == super)
3951     super = NULL;
3952
3953   class_id = parser_qualified_classname (raw_name);
3954   decl = IDENTIFIER_CLASS_VALUE (class_id);
3955   EXPR_WFL_NODE (id) = class_id;
3956
3957   /* Basic check: scope, redefinition, modifiers */
3958   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3959     {
3960       PUSH_ERROR ();
3961       return NULL_TREE;
3962     }
3963
3964   /* Suspend the current parsing context if we're parsing an inner
3965      class or an anonymous class. */
3966   if (CPC_INNER_P ())
3967     {
3968       java_parser_context_suspend ();
3969       /* Interface members are public. */
3970       if (CLASS_INTERFACE (GET_CPC ()))
3971         flags |= ACC_PUBLIC;
3972     }
3973
3974   /* Push a new context for (static) initialized upon declaration fields */
3975   java_parser_context_push_initialized_field ();
3976
3977   /* Class modifier check:
3978        - Allowed modifier (already done at that point)
3979        - abstract AND final forbidden
3980        - Public classes defined in the correct file */
3981   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
3982     parse_error_context
3983       (id, "Class `%s' can't be declared both abstract and final",
3984        IDENTIFIER_POINTER (raw_name));
3985
3986   /* Create a new decl if DECL is NULL, otherwise fix it */
3987   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
3988
3989   /* If SUPER exists, use it, otherwise use Object */
3990   if (super)
3991     {
3992       /* Can't extend java.lang.Object */
3993       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
3994         {
3995           parse_error_context (id, "Can't extend `java.lang.Object'");
3996           return NULL_TREE;
3997         }
3998
3999       super_decl_type =
4000         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4001     }
4002   else if (TREE_TYPE (decl) != object_type_node)
4003     super_decl_type = object_type_node;
4004   /* We're defining java.lang.Object */
4005   else
4006     super_decl_type = NULL_TREE;
4007
4008   /* A class nested in an interface is implicitly static. */
4009   if (INNER_CLASS_DECL_P (decl)
4010       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4011     {
4012       flags |= ACC_STATIC;
4013     }
4014
4015   /* Set super info and mark the class as complete. */
4016   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4017                   ctxp->interface_number);
4018   ctxp->interface_number = 0;
4019   CLASS_COMPLETE_P (decl) = 1;
4020   add_superinterfaces (decl, interfaces);
4021
4022   /* Add the private this$<n> field, Replicate final locals still in
4023      scope as private final fields mangled like val$<local_name>.
4024      This doesn't not occur for top level (static) inner classes. */
4025   if (PURE_INNER_CLASS_DECL_P (decl))
4026     add_inner_class_fields (decl, current_function_decl);
4027
4028   /* If doing xref, store the location at which the inherited class
4029      (if any) was seen. */
4030   if (flag_emit_xref && super)
4031     DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4032
4033   /* Eventually sets the @deprecated tag flag */
4034   CHECK_DEPRECATED (decl);
4035
4036   /* Reset the anonymous class counter when declaring non inner classes */
4037   if (!INNER_CLASS_DECL_P (decl))
4038     anonymous_class_counter = 1;
4039
4040   return decl;
4041 }
4042
4043 /* End a class declaration: register the statements used to create
4044    finit$ and <clinit>, pop the current class and resume the prior
4045    parser context if necessary.  */
4046
4047 static void
4048 end_class_declaration (int resume)
4049 {
4050   /* If an error occurred, context weren't pushed and won't need to be
4051      popped by a resume. */
4052   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4053
4054   if (GET_CPC () != error_mark_node)
4055     dump_java_tree (TDI_class, GET_CPC ());
4056
4057   java_parser_context_pop_initialized_field ();
4058   POP_CPC ();
4059   if (resume && no_error_occurred)
4060     java_parser_context_resume ();
4061
4062   /* We're ending a class declaration, this is a good time to reset
4063      the interface cout. Note that might have been already done in
4064      create_interface, but if at that time an inner class was being
4065      dealt with, the interface count was reset in a context created
4066      for the sake of handling inner classes declaration. */
4067   ctxp->interface_number = 0;
4068 }
4069
4070 static void
4071 add_inner_class_fields (tree class_decl, tree fct_decl)
4072 {
4073   tree block, marker, f;
4074
4075   f = add_field (TREE_TYPE (class_decl),
4076                  build_current_thisn (TREE_TYPE (class_decl)),
4077                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4078                  ACC_PRIVATE);
4079   FIELD_THISN (f) = 1;
4080
4081   if (!fct_decl)
4082     return;
4083
4084   for (block = GET_CURRENT_BLOCK (fct_decl);
4085        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4086     {
4087       tree decl;
4088       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4089         {
4090           tree name, pname;
4091           tree wfl, init, list;
4092
4093           /* Avoid non final arguments. */
4094           if (!LOCAL_FINAL_P (decl))
4095             continue;
4096
4097           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4098           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4099           wfl = build_wfl_node (name);
4100           init = build_wfl_node (pname);
4101           /* Build an initialization for the field: it will be
4102              initialized by a parameter added to finit$, bearing a
4103              mangled name of the field itself (param$<n>.) The
4104              parameter is provided to finit$ by the constructor
4105              invoking it (hence the constructor will also feature a
4106              hidden parameter, set to the value of the outer context
4107              local at the time the inner class is created.)
4108
4109              Note: we take into account all possible locals that can
4110              be accessed by the inner class. It's actually not trivial
4111              to minimize these aliases down to the ones really
4112              used. One way to do that would be to expand all regular
4113              methods first, then finit$ to get a picture of what's
4114              used.  It works with the exception that we would have to
4115              go back on all constructor invoked in regular methods to
4116              have their invocation reworked (to include the right amount
4117              of alias initializer parameters.)
4118
4119              The only real way around, I think, is a first pass to
4120              identify locals really used in the inner class. We leave
4121              the flag FIELD_LOCAL_ALIAS_USED around for that future
4122              use.
4123
4124              On the other hand, it only affect local inner classes,
4125              whose constructors (and finit$ call) will be featuring
4126              unnecessary arguments. It's easy for a developer to keep
4127              this number of parameter down by using the `final'
4128              keyword only when necessary. For the time being, we can
4129              issue a warning on unnecessary finals. FIXME */
4130           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4131                                    wfl, init);
4132
4133           /* Register the field. The TREE_LIST holding the part
4134              initialized/initializer will be marked ARG_FINAL_P so
4135              that the created field can be marked
4136              FIELD_LOCAL_ALIAS. */
4137           list = build_tree_list (wfl, init);
4138           ARG_FINAL_P (list) = 1;
4139           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4140         }
4141     }
4142
4143   if (!CPC_INITIALIZER_STMT (ctxp))
4144     return;
4145
4146   /* If we ever registered an alias field, insert and marker to
4147      remember where the list ends. The second part of the list (the one
4148      featuring initialized fields) so it can be later reversed to
4149      enforce 8.5. The marker will be removed during that operation. */
4150   marker = build_tree_list (NULL_TREE, NULL_TREE);
4151   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4152   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4153 }
4154
4155 /* Can't use lookup_field () since we don't want to load the class and
4156    can't set the CLASS_LOADED_P flag */
4157
4158 static tree
4159 find_field (tree class, tree name)
4160 {
4161   tree decl;
4162   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4163     {
4164       if (DECL_NAME (decl) == name)
4165         return decl;
4166     }
4167   return NULL_TREE;
4168 }
4169
4170 /* Wrap around lookup_field that doesn't potentially upset the value
4171    of CLASS */
4172
4173 static tree
4174 lookup_field_wrapper (tree class, tree name)
4175 {
4176   tree type = class;
4177   tree decl = NULL_TREE;
4178   java_parser_context_save_global ();
4179
4180   /* Last chance: if we're within the context of an inner class, we
4181      might be trying to access a local variable defined in an outer
4182      context. We try to look for it now. */
4183   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4184     {
4185       tree new_name;
4186       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4187       decl = lookup_field (&type, new_name);
4188       if (decl && decl != error_mark_node)
4189         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4190     }
4191   if (!decl || decl == error_mark_node)
4192     {
4193       type = class;
4194       decl = lookup_field (&type, name);
4195     }
4196
4197   /* If the field still hasn't been found, try the next enclosing context. */
4198   if (!decl && INNER_CLASS_TYPE_P (class))
4199     {
4200       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4201       decl = lookup_field_wrapper (outer_type, name);
4202     }
4203
4204   java_parser_context_restore_global ();
4205   return decl == error_mark_node ? NULL : decl;
4206 }
4207
4208 /* Find duplicate field within the same class declarations and report
4209    the error. Returns 1 if a duplicated field was found, 0
4210    otherwise.  */
4211
4212 static int
4213 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4214 {
4215   /* This might be modified to work with method decl as well */
4216   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4217   if (decl)
4218     {
4219       char *t1 = xstrdup (purify_type_name
4220                          ((TREE_CODE (new_type) == POINTER_TYPE
4221                            && TREE_TYPE (new_type) == NULL_TREE) ?
4222                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4223                           lang_printable_name (new_type, 1)));
4224       /* The type may not have been completed by the time we report
4225          the error */
4226       char *t2 = xstrdup (purify_type_name
4227                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4228                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4229                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4230                           lang_printable_name (TREE_TYPE (decl), 1)));
4231       parse_error_context
4232         (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4233          t1, IDENTIFIER_POINTER (new_field_name),
4234          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4235          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4236       free (t1);
4237       free (t2);
4238       return 1;
4239     }
4240   return 0;
4241 }
4242
4243 /* Field registration routine. If TYPE doesn't exist, field
4244    declarations are linked to the undefined TYPE dependency list, to
4245    be later resolved in java_complete_class () */
4246
4247 static void
4248 register_fields (int flags, tree type, tree variable_list)
4249 {
4250   tree current, saved_type;
4251   tree class_type = NULL_TREE;
4252   int saved_lineno = input_line;
4253   int must_chain = 0;
4254   tree wfl = NULL_TREE;
4255
4256   if (GET_CPC ())
4257     class_type = TREE_TYPE (GET_CPC ());
4258
4259   if (!class_type || class_type == error_mark_node)
4260     return;
4261
4262   /* If we're adding fields to interfaces, those fields are public,
4263      static, final */
4264   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4265     {
4266       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4267                                  flags, ACC_PUBLIC, "interface field(s)");
4268       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4269                                  flags, ACC_STATIC, "interface field(s)");
4270       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4271                                  flags, ACC_FINAL, "interface field(s)");
4272       check_modifiers ("Illegal interface member modifier `%s'", flags,
4273                        INTERFACE_FIELD_MODIFIERS);
4274       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4275     }
4276
4277   /* Obtain a suitable type for resolution, if necessary */
4278   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4279
4280   /* If TYPE is fully resolved and we don't have a reference, make one */
4281   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4282
4283   for (current = variable_list, saved_type = type; current;
4284        current = TREE_CHAIN (current), type = saved_type)
4285     {
4286       tree real_type;
4287       tree field_decl;
4288       tree cl = TREE_PURPOSE (current);
4289       tree init = TREE_VALUE (current);
4290       tree current_name = EXPR_WFL_NODE (cl);
4291
4292       /* Can't declare non-final static fields in inner classes */
4293       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4294           && !(flags & ACC_FINAL))
4295         parse_error_context
4296           (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4297            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4298            lang_printable_name (class_type, 0));
4299
4300       /* Process NAME, as it may specify extra dimension(s) for it */
4301       type = build_array_from_name (type, wfl, current_name, &current_name);
4302
4303       /* Type adjustment. We may have just readjusted TYPE because
4304          the variable specified more dimensions. Make sure we have
4305          a reference if we can and don't have one already. Also
4306          change the name if we have an init. */
4307       if (type != saved_type)
4308         {
4309           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4310           if (init)
4311             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4312         }
4313
4314       real_type = GET_REAL_TYPE (type);
4315       /* Check for redeclarations */
4316       if (duplicate_declaration_error_p (current_name, real_type, cl))
4317         continue;
4318
4319       /* Set lineno to the line the field was found and create a
4320          declaration for it. Eventually sets the @deprecated tag flag. */
4321       if (flag_emit_xref)
4322         input_line = EXPR_WFL_LINECOL (cl);
4323       else
4324         input_line = EXPR_WFL_LINENO (cl);
4325       field_decl = add_field (class_type, current_name, real_type, flags);
4326       CHECK_DEPRECATED_NO_RESET (field_decl);
4327
4328       /* If the field denotes a final instance variable, then we
4329          allocate a LANG_DECL_SPECIFIC part to keep track of its
4330          initialization. We also mark whether the field was
4331          initialized upon its declaration. We don't do that if the
4332          created field is an alias to a final local. */
4333       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4334         {
4335           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4336           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4337         }
4338
4339       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4340          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4341          hide parameters to this inner class finit$ and
4342          constructors. It also means that the field isn't final per
4343          say. */
4344       if (ARG_FINAL_P (current))
4345         {
4346           FIELD_LOCAL_ALIAS (field_decl) = 1;
4347           FIELD_FINAL (field_decl) = 0;
4348         }
4349
4350       /* Check if we must chain. */
4351       if (must_chain)
4352         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4353
4354       /* If we have an initialization value tied to the field */
4355       if (init)
4356         {
4357           /* The field is declared static */
4358           if (flags & ACC_STATIC)
4359             {
4360               /* We include the field and its initialization part into
4361                  a list used to generate <clinit>. After <clinit> is
4362                  walked, field initializations will be processed and
4363                  fields initialized with known constants will be taken
4364                  out of <clinit> and have their DECL_INITIAL set
4365                  appropriately. */
4366               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4367               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4368               if (TREE_OPERAND (init, 1)
4369                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4370                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4371             }
4372           /* A non-static field declared with an immediate initialization is
4373              to be initialized in <init>, if any.  This field is remembered
4374              to be processed at the time of the generation of <init>. */
4375           else
4376             {
4377               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4378               SET_CPC_INITIALIZER_STMT (ctxp, init);
4379             }
4380           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4381           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4382         }
4383     }
4384
4385   CLEAR_DEPRECATED;
4386   input_line = saved_lineno;
4387 }
4388
4389 /* Generate finit$, using the list of initialized fields to populate
4390    its body. finit$'s parameter(s) list is adjusted to include the
4391    one(s) used to initialized the field(s) caching outer context
4392    local(s).  */
4393
4394 static tree
4395 generate_finit (tree class_type)
4396 {
4397   int count = 0;
4398   tree list = TYPE_FINIT_STMT_LIST (class_type);
4399   tree mdecl, current, parms;
4400
4401   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4402                                                   class_type, NULL_TREE,
4403                                                   &count);
4404   CRAFTED_PARAM_LIST_FIXUP (parms);
4405   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4406                                     finit_identifier_node, parms);
4407   fix_method_argument_names (parms, mdecl);
4408   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4409                        mdecl, NULL_TREE);
4410   DECL_FUNCTION_NAP (mdecl) = count;
4411   start_artificial_method_body (mdecl);
4412
4413   for (current = list; current; current = TREE_CHAIN (current))
4414     java_method_add_stmt (mdecl,
4415                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4416                                                 current));
4417   end_artificial_method_body (mdecl);
4418   return mdecl;
4419 }
4420
4421 /* Generate a function to run the instance initialization code. The
4422    private method is called `instinit$'. Unless we're dealing with an
4423    anonymous class, we determine whether all ctors of CLASS_TYPE
4424    declare a checked exception in their `throws' clause in order to
4425    see whether it's necessary to encapsulate the instance initializer
4426    statements in a try/catch/rethrow sequence.  */
4427
4428 static tree
4429 generate_instinit (tree class_type)
4430 {
4431   tree current;
4432   tree compound = NULL_TREE;
4433   tree parms = tree_cons (this_identifier_node,
4434                           build_pointer_type (class_type), end_params_node);
4435   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4436                                          void_type_node,
4437                                          instinit_identifier_node, parms);
4438
4439   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4440                        mdecl, NULL_TREE);
4441
4442   /* Gather all the statements in a compound */
4443   for (current = TYPE_II_STMT_LIST (class_type);
4444        current; current = TREE_CHAIN (current))
4445     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4446
4447   /* We need to encapsulate COMPOUND by a try/catch statement to
4448      rethrow exceptions that might occur in the instance initializer.
4449      We do that only if all ctors of CLASS_TYPE are set to catch a
4450      checked exception. This doesn't apply to anonymous classes (since
4451      they don't have declared ctors.) */
4452   if (!ANONYMOUS_CLASS_P (class_type) &&
4453       ctors_unchecked_throws_clause_p (class_type))
4454     {
4455       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4456                                              build1 (THROW_EXPR, NULL_TREE,
4457                                                      build_wfl_node (wpv_id)));
4458       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4459                                                       exception_type_node);
4460     }
4461
4462   start_artificial_method_body (mdecl);
4463   java_method_add_stmt (mdecl, compound);
4464   end_artificial_method_body (mdecl);
4465
4466   return mdecl;
4467 }
4468
4469 /* FIXME */
4470 static tree
4471 build_instinit_invocation (tree class_type)
4472 {
4473   tree to_return = NULL_TREE;
4474
4475   if (TYPE_II_STMT_LIST (class_type))
4476     {
4477       tree parm = build_tree_list (NULL_TREE,
4478                                    build_wfl_node (this_identifier_node));
4479       to_return =
4480         build_method_invocation (build_wfl_node (instinit_identifier_node),
4481                                  parm);
4482     }
4483   return to_return;
4484 }
4485
4486 /* Shared across method_declarator and method_header to remember the
4487    patch stage that was reached during the declaration of the method.
4488    A method DECL is built differently is there is no patch
4489    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4490    pending on the currently defined method.  */
4491
4492 static int patch_stage;
4493
4494 /* Check the method declaration and add the method to its current
4495    class.  If the argument list is known to contain incomplete types,
4496    the method is partially added and the registration will be resume
4497    once the method arguments resolved. If TYPE is NULL, we're dealing
4498    with a constructor.  */
4499
4500 static tree
4501 method_header (int flags, tree type, tree mdecl, tree throws)
4502 {
4503   tree type_wfl = NULL_TREE;
4504   tree meth_name = NULL_TREE;
4505   tree current, orig_arg, this_class = NULL;
4506   tree id, meth;
4507   int saved_lineno;
4508   int constructor_ok = 0, must_chain;
4509   int count;
4510
4511   if (mdecl == error_mark_node)
4512     return error_mark_node;
4513   meth = TREE_VALUE (mdecl);
4514   id = TREE_PURPOSE (mdecl);
4515
4516   check_modifiers_consistency (flags);
4517
4518   if (GET_CPC ())
4519     this_class = TREE_TYPE (GET_CPC ());
4520
4521   if (!this_class || this_class == error_mark_node)
4522     return NULL_TREE;
4523
4524   /* There are some forbidden modifiers for an abstract method and its
4525      class must be abstract as well.  */
4526   if (type && (flags & ACC_ABSTRACT))
4527     {
4528       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4529       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4530       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4531       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4532       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4533       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4534       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4535           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4536         parse_error_context
4537           (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4538            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4539            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4540     }
4541
4542   /* A native method can't be strictfp.  */
4543   if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4544     parse_error_context (id, "native method `%s' can't be strictfp",
4545                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4546   /* No such thing as a transient or volatile method.  */
4547   if ((flags & ACC_TRANSIENT))
4548     parse_error_context (id, "method `%s' can't be transient",
4549                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4550   if ((flags & ACC_VOLATILE))
4551     parse_error_context (id, "method `%s' can't be volatile",
4552                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4553
4554   /* Things to be checked when declaring a constructor */
4555   if (!type)
4556     {
4557       int ec = java_error_count;
4558       /* 8.6: Constructor declarations: we might be trying to define a
4559          method without specifying a return type. */
4560       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4561         parse_error_context
4562           (id, "Invalid method declaration, return type required");
4563       /* 8.6.3: Constructor modifiers */
4564       else
4565         {
4566           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4567           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4568           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4569           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4570           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4571           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4572         }
4573       /* If we found error here, we don't consider it's OK to tread
4574          the method definition as a constructor, for the rest of this
4575          function */
4576       if (ec == java_error_count)
4577         constructor_ok = 1;
4578     }
4579
4580   /* Method declared within the scope of an interface are implicitly
4581      abstract and public. Conflicts with other erroneously provided
4582      modifiers are checked right after. */
4583
4584   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4585     {
4586       /* If FLAGS isn't set because of a modifier, turn the
4587          corresponding modifier WFL to NULL so we issue a warning on
4588          the obsolete use of the modifier */
4589       if (!(flags & ACC_PUBLIC))
4590         MODIFIER_WFL (PUBLIC_TK) = NULL;
4591       if (!(flags & ACC_ABSTRACT))
4592         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4593       flags |= ACC_PUBLIC;
4594       flags |= ACC_ABSTRACT;
4595     }
4596
4597   /* Inner class can't declare static methods */
4598   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4599     {
4600       parse_error_context
4601         (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4602          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4603          lang_printable_name (this_class, 0));
4604     }
4605
4606   /* Modifiers context reset moved up, so abstract method declaration
4607      modifiers can be later checked.  */
4608
4609   /* Set constructor returned type to void and method name to <init>,
4610      unless we found an error identifier the constructor (in which
4611      case we retain the original name) */
4612   if (!type)
4613     {
4614       type = void_type_node;
4615       if (constructor_ok)
4616         meth_name = init_identifier_node;
4617     }
4618   else
4619     meth_name = EXPR_WFL_NODE (id);
4620
4621   /* Do the returned type resolution and registration if necessary */
4622   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4623
4624   if (meth_name)
4625     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4626   EXPR_WFL_NODE (id) = meth_name;
4627   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4628
4629   if (must_chain)
4630     {
4631       patch_stage = JDEP_METHOD_RETURN;
4632       register_incomplete_type (patch_stage, type_wfl, id, type);
4633       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4634     }
4635   else
4636     TREE_TYPE (meth) = type;
4637
4638   saved_lineno = input_line;
4639   /* When defining an abstract or interface method, the curly
4640      bracket at level 1 doesn't exist because there is no function
4641      body */
4642   input_line = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4643             EXPR_WFL_LINENO (id));
4644
4645   /* Remember the original argument list */
4646   orig_arg = TYPE_ARG_TYPES (meth);
4647
4648   if (patch_stage)              /* includes ret type and/or all args */
4649     {
4650       jdep *jdep;
4651       meth = add_method_1 (this_class, flags, meth_name, meth);
4652       /* Patch for the return type */
4653       if (patch_stage == JDEP_METHOD_RETURN)
4654         {
4655           jdep = CLASSD_LAST (ctxp->classd_list);
4656           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4657         }
4658       /* This is the stop JDEP. METH allows the function's signature
4659          to be computed. */
4660       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4661     }
4662   else
4663     meth = add_method (this_class, flags, meth_name,
4664                        build_java_signature (meth));
4665
4666   /* Remember final parameters */
4667   MARK_FINAL_PARMS (meth, orig_arg);
4668
4669   /* Fix the method argument list so we have the argument name
4670      information */
4671   fix_method_argument_names (orig_arg, meth);
4672
4673   /* Register the parameter number and re-install the current line
4674      number */
4675   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4676   input_line = saved_lineno;
4677
4678   /* Register exception specified by the `throws' keyword for
4679      resolution and set the method decl appropriate field to the list.
4680      Note: the grammar ensures that what we get here are class
4681      types. */
4682   if (throws)
4683     {
4684       throws = nreverse (throws);
4685       for (current = throws; current; current = TREE_CHAIN (current))
4686         {
4687           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4688                                     NULL_TREE, NULL_TREE);
4689           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4690             &TREE_VALUE (current);
4691         }
4692       DECL_FUNCTION_THROWS (meth) = throws;
4693     }
4694
4695   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4696     DECL_FUNCTION_WFL (meth) = id;
4697
4698   /* Set the flag if we correctly processed a constructor */
4699   if (constructor_ok)
4700     {
4701       DECL_CONSTRUCTOR_P (meth) = 1;
4702       /* Compute and store the number of artificial parameters declared
4703          for this constructor */
4704       for (count = 0, current = TYPE_FIELDS (this_class); current;
4705            current = TREE_CHAIN (current))
4706         if (FIELD_LOCAL_ALIAS (current))
4707           count++;
4708       DECL_FUNCTION_NAP (meth) = count;
4709     }
4710
4711   /* Eventually set the @deprecated tag flag */
4712   CHECK_DEPRECATED (meth);
4713
4714   /* If doing xref, store column and line number information instead
4715      of the line number only. */
4716   if (flag_emit_xref)
4717     DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4718
4719   return meth;
4720 }
4721
4722 static void
4723 fix_method_argument_names (tree orig_arg, tree meth)
4724 {
4725   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4726   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4727     {
4728       TREE_PURPOSE (arg) = this_identifier_node;
4729       arg = TREE_CHAIN (arg);
4730     }
4731   while (orig_arg != end_params_node)
4732     {
4733       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4734       orig_arg = TREE_CHAIN (orig_arg);
4735       arg = TREE_CHAIN (arg);
4736     }
4737 }
4738
4739 /* Complete the method declaration with METHOD_BODY.  */
4740
4741 static void
4742 finish_method_declaration (tree method_body)
4743 {
4744   int flags;
4745
4746   if (!current_function_decl)
4747     return;
4748
4749   flags = get_access_flags_from_decl (current_function_decl);
4750
4751   /* 8.4.5 Method Body */
4752   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4753     {
4754       tree name = DECL_NAME (current_function_decl);
4755       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4756                            "%s method `%s' can't have a body defined",
4757                            (METHOD_NATIVE (current_function_decl) ?
4758                             "Native" : "Abstract"),
4759                            IDENTIFIER_POINTER (name));
4760       method_body = NULL_TREE;
4761     }
4762   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4763     {
4764       tree name = DECL_NAME (current_function_decl);
4765       parse_error_context
4766         (DECL_FUNCTION_WFL (current_function_decl),
4767          "Non native and non abstract method `%s' must have a body defined",
4768          IDENTIFIER_POINTER (name));
4769       method_body = NULL_TREE;
4770     }
4771
4772   if (flag_emit_class_files && method_body
4773       && TREE_CODE (method_body) == NOP_EXPR
4774       && TREE_TYPE (current_function_decl)
4775       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4776     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4777
4778   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4779   maybe_absorb_scoping_blocks ();
4780   /* Exit function's body */
4781   exit_block ();
4782   /* Merge last line of the function with first line, directly in the
4783      function decl. It will be used to emit correct debug info. */
4784   if (!flag_emit_xref)
4785     DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4786
4787   /* Since function's argument's list are shared, reset the
4788      ARG_FINAL_P parameter that might have been set on some of this
4789      function parameters. */
4790   UNMARK_FINAL_PARMS (current_function_decl);
4791
4792   /* So we don't have an irrelevant function declaration context for
4793      the next static block we'll see. */
4794   current_function_decl = NULL_TREE;
4795 }
4796
4797 /* Build a an error message for constructor circularity errors.  */
4798
4799 static char *
4800 constructor_circularity_msg (tree from, tree to)
4801 {
4802   static char string [4096];
4803   char *t = xstrdup (lang_printable_name (from, 0));
4804   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4805   free (t);
4806   return string;
4807 }
4808
4809 /* Verify a circular call to METH. Return 1 if an error is found, 0
4810    otherwise.  */
4811
4812 static GTY(()) tree vcc_list;
4813 static int
4814 verify_constructor_circularity (tree meth, tree current)
4815 {
4816   tree c;
4817
4818   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4819     {
4820       if (TREE_VALUE (c) == meth)
4821         {
4822           char *t;
4823           if (vcc_list)
4824             {
4825               tree liste;
4826               vcc_list = nreverse (vcc_list);
4827               for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4828                 {
4829                   parse_error_context
4830                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4831                      constructor_circularity_msg
4832                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4833                   java_error_count--;
4834                 }
4835             }
4836           t = xstrdup (lang_printable_name (meth, 0));
4837           parse_error_context (TREE_PURPOSE (c),
4838                                "%s: recursive invocation of constructor `%s'",
4839                                constructor_circularity_msg (current, meth), t);
4840           free (t);
4841           vcc_list = NULL_TREE;
4842           return 1;
4843         }
4844     }
4845   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4846     {
4847       vcc_list = tree_cons (c, current, vcc_list);
4848       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4849         return 1;
4850       vcc_list = TREE_CHAIN (vcc_list);
4851     }
4852   return 0;
4853 }
4854
4855 /* Check modifiers that can be declared but exclusively */
4856
4857 static void
4858 check_modifiers_consistency (int flags)
4859 {
4860   int acc_count = 0;
4861   tree cl = NULL_TREE;
4862
4863   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4864   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4865   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4866   if (acc_count > 1)
4867     parse_error_context
4868       (cl, "Inconsistent member declaration.  At most one of `public', `private', or `protected' may be specified");
4869
4870   acc_count = 0;
4871   cl = NULL_TREE;
4872   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4873   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4874   if (acc_count > 1)
4875     parse_error_context (cl,
4876                          "Inconsistent member declaration.  At most one of `final' or `volatile' may be specified");
4877 }
4878
4879 /* Check the methode header METH for abstract specifics features */
4880
4881 static void
4882 check_abstract_method_header (tree meth)
4883 {
4884   int flags = get_access_flags_from_decl (meth);
4885
4886   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4887                               ACC_ABSTRACT, "abstract method",
4888                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4889   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4890                               ACC_PUBLIC, "abstract method",
4891                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4892
4893   check_modifiers ("Illegal modifier `%s' for interface method",
4894                   flags, INTERFACE_METHOD_MODIFIERS);
4895 }
4896
4897 /* Create a FUNCTION_TYPE node and start augmenting it with the
4898    declared function arguments. Arguments type that can't be resolved
4899    are left as they are, but the returned node is marked as containing
4900    incomplete types.  */
4901
4902 static tree
4903 method_declarator (tree id, tree list)
4904 {
4905   tree arg_types = NULL_TREE, current, node;
4906   tree meth = make_node (FUNCTION_TYPE);
4907   jdep *jdep;
4908
4909   patch_stage = JDEP_NO_PATCH;
4910
4911   if (GET_CPC () == error_mark_node)
4912     return error_mark_node;
4913
4914   /* If we're dealing with an inner class constructor, we hide the
4915      this$<n> decl in the name field of its parameter declaration.  We
4916      also might have to hide the outer context local alias
4917      initializers. Not done when the class is a toplevel class. */
4918   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4919       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4920     {
4921       tree aliases_list, type, thisn;
4922       /* First the aliases, linked to the regular parameters */
4923       aliases_list =
4924         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4925                                                 TREE_TYPE (GET_CPC ()),
4926                                                 NULL_TREE, NULL);
4927       list = chainon (nreverse (aliases_list), list);
4928
4929       /* Then this$<n> */
4930       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4931       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4932       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4933                         list);
4934     }
4935
4936   for (current = list; current; current = TREE_CHAIN (current))
4937     {
4938       int must_chain = 0;
4939       tree wfl_name = TREE_PURPOSE (current);
4940       tree type = TREE_VALUE (current);
4941       tree name = EXPR_WFL_NODE (wfl_name);
4942       tree already, arg_node;
4943       tree type_wfl = NULL_TREE;
4944       tree real_type;
4945
4946       /* Obtain a suitable type for resolution, if necessary */
4947       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4948
4949       /* Process NAME, as it may specify extra dimension(s) for it */
4950       type = build_array_from_name (type, type_wfl, name, &name);
4951       EXPR_WFL_NODE (wfl_name) = name;
4952
4953       real_type = GET_REAL_TYPE (type);
4954       if (TREE_CODE (real_type) == RECORD_TYPE)
4955         {
4956           real_type = promote_type (real_type);
4957           if (TREE_CODE (type) == TREE_LIST)
4958             TREE_PURPOSE (type) = real_type;
4959         }
4960
4961       /* Check redefinition */
4962       for (already = arg_types; already; already = TREE_CHAIN (already))
4963         if (TREE_PURPOSE (already) == name)
4964           {
4965             parse_error_context
4966               (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4967                IDENTIFIER_POINTER (name),
4968                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4969             break;
4970           }
4971
4972       /* If we've an incomplete argument type, we know there is a location
4973          to patch when the type get resolved, later.  */
4974       jdep = NULL;
4975       if (must_chain)
4976         {
4977           patch_stage = JDEP_METHOD;
4978           type = register_incomplete_type (patch_stage,
4979                                            type_wfl, wfl_name, type);
4980           jdep = CLASSD_LAST (ctxp->classd_list);
4981           JDEP_MISC (jdep) = id;
4982         }
4983
4984       /* The argument node: a name and a (possibly) incomplete type.  */
4985       arg_node = build_tree_list (name, real_type);
4986       /* Remember arguments declared final. */
4987       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
4988
4989       if (jdep)
4990         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
4991       TREE_CHAIN (arg_node) = arg_types;
4992       arg_types = arg_node;
4993     }
4994   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
4995   node = build_tree_list (id, meth);
4996   return node;
4997 }
4998
4999 static int
5000 unresolved_type_p (tree wfl, tree *returned)
5001
5002 {
5003   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5004     {
5005       if (returned)
5006         {
5007           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5008           if (decl && current_class && (decl == TYPE_NAME (current_class)))
5009             *returned = TREE_TYPE (decl);
5010           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5011             *returned = TREE_TYPE (GET_CPC ());
5012           else
5013             *returned = NULL_TREE;
5014         }
5015       return 1;
5016     }
5017   if (returned)
5018     *returned = wfl;
5019   return 0;
5020 }
5021
5022 /* From NAME, build a qualified identifier node using the
5023    qualification from the current package definition. */
5024
5025 static tree
5026 parser_qualified_classname (tree name)
5027 {
5028   tree nested_class_name;
5029
5030   if ((nested_class_name = maybe_make_nested_class_name (name)))
5031     return nested_class_name;
5032
5033   if (ctxp->package)
5034     return merge_qualified_name (ctxp->package, name);
5035   else
5036     return name;
5037 }
5038
5039 /* Called once the type a interface extends is resolved. Returns 0 if
5040    everything is OK.  */
5041
5042 static int
5043 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5044 {
5045   tree super_type = TREE_TYPE (super_decl);
5046
5047   /* Has to be an interface */
5048   if (!CLASS_INTERFACE (super_decl))
5049     {
5050       parse_error_context
5051         (this_wfl, "%s `%s' can't implement/extend %s `%s'",
5052          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5053           "Interface" : "Class"),
5054          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5055          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5056          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5057       return 1;
5058     }
5059
5060   /* Check top-level interface access. Inner classes are subject to member
5061      access rules (6.6.1). */
5062   if (! INNER_CLASS_P (super_type)
5063       && check_pkg_class_access (DECL_NAME (super_decl),
5064                                  lookup_cl (this_decl), true))
5065     return 1;
5066
5067   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5068                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5069                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5070   return 0;
5071 }
5072
5073 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5074    0 if everything is OK.  */
5075
5076 static int
5077 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5078 {
5079   tree super_type = TREE_TYPE (super_decl);
5080
5081   /* SUPER should be a CLASS (neither an array nor an interface) */
5082   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5083     {
5084       parse_error_context
5085         (wfl, "Class `%s' can't subclass %s `%s'",
5086          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5087          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5088          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5089       return 1;
5090     }
5091
5092   if (CLASS_FINAL (TYPE_NAME (super_type)))
5093     {
5094       parse_error_context (wfl, "Can't subclass final classes: %s",
5095                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5096       return 1;
5097     }
5098
5099   /* Check top-level class scope. Inner classes are subject to member access
5100      rules (6.6.1). */
5101   if (! INNER_CLASS_P (super_type)
5102       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true)))
5103     return 1;
5104
5105   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5106                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5107                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5108   return 0;
5109 }
5110
5111 /* Create a new dependency list and link it (in a LIFO manner) to the
5112    CTXP list of type dependency list.  */
5113
5114 static void
5115 create_jdep_list (struct parser_ctxt *ctxp)
5116 {
5117   jdeplist *new = xmalloc (sizeof (jdeplist));
5118   new->first = new->last = NULL;
5119   new->next = ctxp->classd_list;
5120   ctxp->classd_list = new;
5121 }
5122
5123 static jdeplist *
5124 reverse_jdep_list (struct parser_ctxt *ctxp)
5125 {
5126   jdeplist *prev = NULL, *current, *next;
5127   for (current = ctxp->classd_list; current; current = next)
5128     {
5129       next = current->next;
5130       current->next = prev;
5131       prev = current;
5132     }
5133   return prev;
5134 }
5135
5136 /* Create a fake pointer based on the ID stored in
5137    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5138    registered again. */
5139
5140 static tree
5141 obtain_incomplete_type (tree type_name)
5142 {
5143   tree ptr = NULL_TREE, name;
5144
5145   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5146     name = EXPR_WFL_NODE (type_name);
5147   else if (INCOMPLETE_TYPE_P (type_name))
5148     name = TYPE_NAME (type_name);
5149   else
5150     abort ();
5151
5152   /* Workaround from build_pointer_type for incomplete types.  */
5153   BUILD_PTR_FROM_NAME (ptr, name);
5154   TYPE_MODE (ptr) = ptr_mode;
5155   layout_type (ptr);
5156
5157   return ptr;
5158 }
5159
5160 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5161    non NULL instead of computing a new fake type based on WFL. The new
5162    dependency is inserted in the current type dependency list, in FIFO
5163    manner.  */
5164
5165 static tree
5166 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5167 {
5168   jdep *new = xmalloc (sizeof (jdep));
5169
5170   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5171     ptr = obtain_incomplete_type (wfl);
5172
5173   JDEP_KIND (new) = kind;
5174   JDEP_DECL (new) = decl;
5175   JDEP_TO_RESOLVE (new) = ptr;
5176   JDEP_WFL (new) = wfl;
5177   JDEP_CHAIN (new) = NULL;
5178   JDEP_MISC (new) = NULL_TREE;
5179   /* For some dependencies, set the enclosing class of the current
5180      class to be the enclosing context */
5181   if ((kind == JDEP_INTERFACE  || kind == JDEP_ANONYMOUS)
5182       && GET_ENCLOSING_CPC ())
5183     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5184   else if (kind == JDEP_SUPER)
5185     JDEP_ENCLOSING (new) = (GET_ENCLOSING_CPC () ?
5186                             TREE_VALUE (GET_ENCLOSING_CPC ()) : NULL_TREE);
5187   else
5188     JDEP_ENCLOSING (new) = GET_CPC ();
5189   JDEP_GET_PATCH (new) = (tree *)NULL;
5190
5191   JDEP_INSERT (ctxp->classd_list, new);
5192
5193   return ptr;
5194 }
5195
5196 /* This checks for circular references with innerclasses. We start
5197    from SOURCE and should never reach TARGET. Extended/implemented
5198    types in SOURCE have their enclosing context checked not to reach
5199    TARGET. When the last enclosing context of SOURCE is reached, its
5200    extended/implemented types are also checked not to reach TARGET.
5201    In case of error, WFL of the offending type is returned; NULL_TREE
5202    otherwise.  */
5203
5204 static tree
5205 check_inner_circular_reference (tree source, tree target)
5206 {
5207   tree basetype_vec = TYPE_BINFO_BASETYPES (source);
5208   tree ctx, cl;
5209   int i;
5210
5211   if (!basetype_vec)
5212     return NULL_TREE;
5213
5214   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5215     {
5216       tree su;
5217
5218       /* We can end up with a NULL_TREE or an incomplete type here if
5219          we encountered previous type resolution errors. It's safe to
5220          simply ignore these cases.  */
5221       if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
5222         continue;
5223       su = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
5224       if (INCOMPLETE_TYPE_P (su))
5225         continue;
5226
5227       if (inherits_from_p (su, target))
5228         return lookup_cl (TYPE_NAME (su));
5229
5230       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5231         {
5232           /* An enclosing context shouldn't be TARGET */
5233           if (ctx == TYPE_NAME (target))
5234             return lookup_cl (TYPE_NAME (su));
5235
5236           /* When we reach the enclosing last context, start a check
5237              on it, with the same target */
5238           if (! DECL_CONTEXT (ctx) &&
5239               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5240             return cl;
5241         }
5242     }
5243   return NULL_TREE;
5244 }
5245
5246 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5247    offending type if a circularity is detected. NULL_TREE is returned
5248    otherwise. TYPE can be an interface or a class.   */
5249
5250 static tree
5251 check_circular_reference (tree type)
5252 {
5253   tree basetype_vec = TYPE_BINFO_BASETYPES (type);
5254   int i;
5255
5256   if (!basetype_vec)
5257     return NULL_TREE;
5258
5259   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5260     {
5261       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5262         return lookup_cl (TYPE_NAME (type));
5263       return NULL_TREE;
5264     }
5265
5266   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5267     {
5268       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
5269       if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
5270           && interface_of_p (type, BINFO_TYPE (vec_elt)))
5271         return lookup_cl (TYPE_NAME (BINFO_TYPE (vec_elt)));
5272     }
5273   return NULL_TREE;
5274 }
5275
5276 void
5277 java_check_circular_reference (void)
5278 {
5279   tree current;
5280   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5281     {
5282       tree type = TREE_TYPE (current);
5283       tree cl;
5284
5285       cl = check_circular_reference (type);
5286       if (! cl)
5287         cl = check_inner_circular_reference (type, type);
5288       if (cl)
5289         parse_error_context (cl, "Cyclic class inheritance%s",
5290                              (cyclic_inheritance_report ?
5291                               cyclic_inheritance_report : ""));
5292     }
5293 }
5294
5295 /* Augment the parameter list PARM with parameters crafted to
5296    initialize outer context locals aliases. Through ARTIFICIAL, a
5297    count is kept of the number of crafted parameters. MODE governs
5298    what eventually gets created: something suitable for a function
5299    creation or a function invocation, either the constructor or
5300    finit$.  */
5301
5302 static tree
5303 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5304                                         int *artificial)
5305 {
5306   tree field;
5307   tree additional_parms = NULL_TREE;
5308
5309   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5310     if (FIELD_LOCAL_ALIAS (field))
5311       {
5312         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5313         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5314         tree mangled_id;
5315
5316         switch (mode)
5317           {
5318           case AIPL_FUNCTION_DECLARATION:
5319             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5320                                                          &buffer [4]);
5321             purpose = build_wfl_node (mangled_id);
5322             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5323               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5324             else
5325               value = TREE_TYPE (field);
5326             break;
5327
5328           case AIPL_FUNCTION_CREATION:
5329             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5330                                                          &buffer [4]);
5331             value = TREE_TYPE (field);
5332             break;
5333
5334           case AIPL_FUNCTION_FINIT_INVOCATION:
5335             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5336                                                          &buffer [4]);
5337             /* Now, this is wrong. purpose should always be the NAME
5338                of something and value its matching value (decl, type,
5339                etc...) FIXME -- but there is a lot to fix. */
5340
5341             /* When invoked for this kind of operation, we already
5342                know whether a field is used or not. */
5343             purpose = TREE_TYPE (field);
5344             value = build_wfl_node (mangled_id);
5345             break;
5346
5347           case AIPL_FUNCTION_CTOR_INVOCATION:
5348             /* There are two case: the constructor invocation happens
5349                outside the local inner, in which case, locales from the outer
5350                context are directly used.
5351
5352                Otherwise, we fold to using the alias directly. */
5353             if (class_type == current_class)
5354               value = field;
5355             else
5356               {
5357                 name = get_identifier (&buffer[4]);
5358                 value = IDENTIFIER_LOCAL_VALUE (name);
5359               }
5360             break;
5361           }
5362         additional_parms = tree_cons (purpose, value, additional_parms);
5363         if (artificial)
5364           *artificial +=1;
5365       }
5366   if (additional_parms)
5367     {
5368       if (ANONYMOUS_CLASS_P (class_type)
5369           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5370         additional_parms = nreverse (additional_parms);
5371       parm = chainon (additional_parms, parm);
5372     }
5373
5374    return parm;
5375 }
5376
5377 /* Craft a constructor for CLASS_DECL -- what we should do when none
5378    where found. ARGS is non NULL when a special signature must be
5379    enforced. This is the case for anonymous classes.  */
5380
5381 static tree
5382 craft_constructor (tree class_decl, tree args)
5383 {
5384   tree class_type = TREE_TYPE (class_decl);
5385   tree parm = NULL_TREE;
5386   int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5387                ACC_PUBLIC : 0);
5388   int i = 0, artificial = 0;
5389   tree decl, ctor_name;
5390   char buffer [80];
5391
5392   /* The constructor name is <init> unless we're dealing with an
5393      anonymous class, in which case the name will be fixed after having
5394      be expanded. */
5395   if (ANONYMOUS_CLASS_P (class_type))
5396     ctor_name = DECL_NAME (class_decl);
5397   else
5398     ctor_name = init_identifier_node;
5399
5400   /* If we're dealing with an inner class constructor, we hide the
5401      this$<n> decl in the name field of its parameter declaration. */
5402   if (PURE_INNER_CLASS_TYPE_P (class_type))
5403     {
5404       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5405       parm = tree_cons (build_current_thisn (class_type),
5406                         build_pointer_type (type), parm);
5407
5408       /* Some more arguments to be hidden here. The values of the local
5409          variables of the outer context that the inner class needs to see. */
5410       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5411                                                      class_type, parm,
5412                                                      &artificial);
5413     }
5414
5415   /* Then if there are any args to be enforced, enforce them now */
5416   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5417     {
5418       sprintf (buffer, "parm%d", i++);
5419       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5420     }
5421
5422   CRAFTED_PARAM_LIST_FIXUP (parm);
5423   decl = create_artificial_method (class_type, flags, void_type_node,
5424                                    ctor_name, parm);
5425   fix_method_argument_names (parm, decl);
5426   /* Now, mark the artificial parameters. */
5427   DECL_FUNCTION_NAP (decl) = artificial;
5428   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5429   DECL_INLINE (decl) = 1;
5430   return decl;
5431 }
5432
5433
5434 /* Fix the constructors. This will be called right after circular
5435    references have been checked. It is necessary to fix constructors
5436    early even if no code generation will take place for that class:
5437    some generated constructor might be required by the class whose
5438    compilation triggered this one to be simply loaded.  */
5439
5440 void
5441 java_fix_constructors (void)
5442 {
5443   tree current;
5444
5445   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5446     {
5447       tree class_type = TREE_TYPE (current);
5448       int saw_ctor = 0;
5449       tree decl;
5450
5451       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5452         continue;
5453
5454       output_class = current_class = class_type;
5455       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5456         {
5457           if (DECL_CONSTRUCTOR_P (decl))
5458             {
5459               fix_constructors (decl);
5460               saw_ctor = 1;
5461             }
5462         }
5463
5464       /* Anonymous class constructor can't be generated that early. */
5465       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5466         craft_constructor (current, NULL_TREE);
5467     }
5468 }
5469
5470 /* safe_layout_class just makes sure that we can load a class without
5471    disrupting the current_class, input_file, lineno, etc, information
5472    about the class processed currently.  */
5473
5474 void
5475 safe_layout_class (tree class)
5476 {
5477   tree save_current_class = current_class;
5478   location_t save_location = input_location;
5479
5480   layout_class (class);
5481
5482   current_class = save_current_class;
5483   input_location = save_location;
5484 }
5485
5486 static tree
5487 jdep_resolve_class (jdep *dep)
5488 {
5489   tree decl;
5490
5491   if (JDEP_RESOLVED_P (dep))
5492     decl = JDEP_RESOLVED_DECL (dep);
5493   else
5494     {
5495       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5496                             JDEP_DECL (dep), JDEP_WFL (dep));
5497       JDEP_RESOLVED (dep, decl);
5498       /* If there is no WFL, that's ok.  We generate this warning
5499          elsewhere.  */
5500       if (decl && JDEP_WFL (dep) != NULL_TREE)
5501         check_deprecation (JDEP_WFL (dep), decl);
5502     }
5503
5504   if (!decl)
5505     complete_class_report_errors (dep);
5506   else if (PURE_INNER_CLASS_DECL_P (decl))
5507     {
5508       tree inner = TREE_TYPE (decl);
5509       if (! CLASS_LOADED_P (inner))
5510         {
5511           safe_layout_class (inner);
5512           if (TYPE_SIZE (inner) == error_mark_node)
5513             TYPE_SIZE (inner) = NULL_TREE;
5514         }
5515       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5516     }
5517   return decl;
5518 }
5519
5520 /* Complete unsatisfied class declaration and their dependencies */
5521
5522 void
5523 java_complete_class (void)
5524 {
5525   tree cclass;
5526   jdeplist *cclassd;
5527   int error_found;
5528   tree type;
5529
5530   /* Process imports */
5531   process_imports ();
5532
5533   /* Reverse things so we have the right order */
5534   ctxp->class_list = nreverse (ctxp->class_list);
5535   ctxp->classd_list = reverse_jdep_list (ctxp);
5536
5537   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5538        cclass && cclassd;
5539        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5540     {
5541       jdep *dep;
5542
5543       /* We keep the compilation unit imports in the class so that
5544          they can be used later to resolve type dependencies that
5545          aren't necessary to solve now. */
5546       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5547       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5548
5549       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5550         {
5551           tree decl;
5552           if (!(decl = jdep_resolve_class (dep)))
5553             continue;
5554
5555           /* Now it's time to patch */
5556           switch (JDEP_KIND (dep))
5557             {
5558             case JDEP_SUPER:
5559               /* Simply patch super */
5560               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5561                 continue;
5562               BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5563                 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5564               break;
5565
5566             case JDEP_FIELD:
5567               {
5568                 /* We do part of the job done in add_field */
5569                 tree field_decl = JDEP_DECL (dep);
5570                 tree field_type = TREE_TYPE (decl);
5571                 if (TREE_CODE (field_type) == RECORD_TYPE)
5572                   field_type = promote_type (field_type);
5573                 TREE_TYPE (field_decl) = field_type;
5574                 DECL_ALIGN (field_decl) = 0;
5575                 DECL_USER_ALIGN (field_decl) = 0;
5576                 layout_decl (field_decl, 0);
5577                 SOURCE_FRONTEND_DEBUG
5578                   (("Completed field/var decl `%s' with `%s'",
5579                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5580                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5581                 break;
5582               }
5583             case JDEP_METHOD:   /* We start patching a method */
5584             case JDEP_METHOD_RETURN:
5585               error_found = 0;
5586               while (1)
5587                 {
5588                   if (decl)
5589                     {
5590                       type = TREE_TYPE(decl);
5591                       if (TREE_CODE (type) == RECORD_TYPE)
5592                         type = promote_type (type);
5593                       JDEP_APPLY_PATCH (dep, type);
5594                       SOURCE_FRONTEND_DEBUG
5595                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5596                            "Completing fct `%s' with ret type `%s'":
5597                            "Completing arg `%s' with type `%s'"),
5598                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5599                                               (JDEP_DECL_WFL (dep))),
5600                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5601                     }
5602                   else
5603                     error_found = 1;
5604                   dep = JDEP_CHAIN (dep);
5605                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5606                     break;
5607                   else
5608                     decl = jdep_resolve_class (dep);
5609                 }
5610               if (!error_found)
5611                 {
5612                   tree mdecl = JDEP_DECL (dep), signature;
5613                   /* Recompute and reset the signature, check first that
5614                      all types are now defined. If they're not,
5615                      don't build the signature. */
5616                   if (check_method_types_complete (mdecl))
5617                     {
5618                       signature = build_java_signature (TREE_TYPE (mdecl));
5619                       set_java_signature (TREE_TYPE (mdecl), signature);
5620                     }
5621                 }
5622               else
5623                 continue;
5624               break;
5625
5626             case JDEP_INTERFACE:
5627               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5628                                                 JDEP_WFL (dep)))
5629                 continue;
5630               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5631               break;
5632
5633             case JDEP_PARM:
5634             case JDEP_VARIABLE:
5635               type = TREE_TYPE(decl);
5636               if (TREE_CODE (type) == RECORD_TYPE)
5637                 type = promote_type (type);
5638               JDEP_APPLY_PATCH (dep, type);
5639               break;
5640
5641             case JDEP_TYPE:
5642               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5643               SOURCE_FRONTEND_DEBUG
5644                 (("Completing a random type dependency on a '%s' node",
5645                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5646               break;
5647
5648             case JDEP_EXCEPTION:
5649               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5650               SOURCE_FRONTEND_DEBUG
5651                 (("Completing `%s' `throws' argument node",
5652                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5653               break;
5654
5655             case JDEP_ANONYMOUS:
5656               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5657               break;
5658
5659             default:
5660               abort ();
5661             }
5662         }
5663     }
5664   return;
5665 }
5666
5667 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5668    array.  */
5669
5670 static tree
5671 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5672 {
5673   tree tname = TYPE_NAME (class_type);
5674   tree resolved_type = TREE_TYPE (class_type);
5675   int array_dims = 0;
5676   tree resolved_type_decl;
5677
5678   if (resolved_type != NULL_TREE)
5679     {
5680       tree resolved_type_decl = TYPE_NAME (resolved_type);
5681       if (resolved_type_decl == NULL_TREE
5682           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5683         {
5684           resolved_type_decl = build_decl (TYPE_DECL,
5685                                            TYPE_NAME (class_type),
5686                                            resolved_type);
5687         }
5688       return resolved_type_decl;
5689     }
5690
5691   /* 1- Check to see if we have an array. If true, find what we really
5692      want to resolve  */
5693   if ((array_dims = build_type_name_from_array_name (tname,
5694                                                      &TYPE_NAME (class_type))))
5695     WFL_STRIP_BRACKET (cl, cl);
5696
5697   /* 2- Resolve the bare type */
5698   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5699                                                decl, cl)))
5700     return NULL_TREE;
5701   resolved_type = TREE_TYPE (resolved_type_decl);
5702
5703   /* 3- If we have an array, reconstruct the array down to its nesting */
5704   if (array_dims)
5705     {
5706       for (; array_dims; array_dims--)
5707         resolved_type = build_java_array_type (resolved_type, -1);
5708       resolved_type_decl = TYPE_NAME (resolved_type);
5709     }
5710   TREE_TYPE (class_type) = resolved_type;
5711   return resolved_type_decl;
5712 }
5713
5714 /* Effectively perform the resolution of class CLASS_TYPE.  DECL or CL
5715    are used to report error messages; CL must either be NULL_TREE or a
5716    WFL wrapping a class.  Do not try to replace TYPE_NAME (class_type)
5717    by a variable, since it is changed by find_in_imports{_on_demand}
5718    and (but it doesn't really matter) qualify_and_find.  */
5719
5720 tree
5721 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5722 {
5723   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5724   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5725   tree decl_result;
5726   htab_t circularity_hash;
5727
5728   if (QUALIFIED_P (TYPE_NAME (class_type)))
5729     {
5730       /* If the type name is of the form `Q . Id', then Q is either a
5731          package name or a class name.  First we try to find Q as a
5732          class and then treat Id as a member type.  If we can't find Q
5733          as a class then we fall through.  */
5734       tree q, left, left_type, right;
5735       if (breakdown_qualified (&left, &right, TYPE_NAME (class_type)) == 0)
5736         {
5737           BUILD_PTR_FROM_NAME (left_type, left);
5738           q = do_resolve_class (enclosing, left_type, decl, cl);
5739           if (q)
5740             {
5741               enclosing = q;
5742               saved_enclosing_type = TREE_TYPE (q);
5743               BUILD_PTR_FROM_NAME (class_type, right);
5744             }
5745         }
5746     }
5747
5748   if (enclosing)
5749     {
5750       /* This hash table is used to register the classes we're going
5751          through when searching the current class as an inner class, in
5752          order to detect circular references. Remember to free it before
5753          returning the section 0- of this function. */
5754       circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5755                                       NULL);
5756
5757       /* 0- Search in the current class as an inner class.
5758          Maybe some code here should be added to load the class or
5759          something, at least if the class isn't an inner class and ended
5760          being loaded from class file. FIXME. */
5761       while (enclosing)
5762         {
5763           new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5764                                                 &super, class_type);
5765           if (new_class_decl)
5766             break;
5767
5768           /* If we haven't found anything because SUPER reached Object and
5769              ENCLOSING happens to be an innerclass, try the enclosing context. */
5770           if ((!super || super == object_type_node) &&
5771               enclosing && INNER_CLASS_DECL_P (enclosing))
5772             enclosing = DECL_CONTEXT (enclosing);
5773           else
5774             enclosing = NULL_TREE;
5775         }
5776
5777       htab_delete (circularity_hash);
5778
5779       if (new_class_decl)
5780         return new_class_decl;
5781     }
5782
5783   /* 1- Check for the type in single imports. This will change
5784      TYPE_NAME() if something relevant is found */
5785   find_in_imports (saved_enclosing_type, class_type);
5786
5787   /* 2- And check for the type in the current compilation unit */
5788   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5789     {
5790       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5791           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5792         load_class (TYPE_NAME (class_type), 0);
5793       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5794     }
5795
5796   /* 3- Search according to the current package definition */
5797   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5798     {
5799       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5800                                              TYPE_NAME (class_type))))
5801         return new_class_decl;
5802     }
5803
5804   /* 4- Check the import on demands. Don't allow bar.baz to be
5805      imported from foo.* */
5806   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5807     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5808       return NULL_TREE;
5809
5810   /* If found in find_in_imports_on_demand, the type has already been
5811      loaded. */
5812   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5813     return new_class_decl;
5814
5815   /* 5- Try with a name qualified with the package name we've seen so far */
5816   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5817     {
5818       tree package;
5819
5820       /* If there is a current package (ctxp->package), it's the first
5821          element of package_list and we can skip it. */
5822       for (package = (ctxp->package ?
5823                       TREE_CHAIN (package_list) : package_list);
5824            package; package = TREE_CHAIN (package))
5825         if ((new_class_decl = qualify_and_find (class_type,
5826                                                TREE_PURPOSE (package),
5827                                                TYPE_NAME (class_type))))
5828           return new_class_decl;
5829     }
5830
5831   /* 5- Check another compilation unit that bears the name of type */
5832   load_class (TYPE_NAME (class_type), 0);
5833
5834   if (!cl)
5835     cl = lookup_cl (decl);
5836
5837   /* If we don't have a value for CL, then we're being called recursively.
5838      We can't check package access just yet, but it will be taken care of
5839      by the caller. */
5840   if (cl)
5841     {
5842       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true))
5843         return NULL_TREE;
5844     }
5845
5846   /* 6- Last call for a resolution */
5847   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5848
5849   /* The final lookup might have registered a.b.c into a.b$c If we
5850      failed at the first lookup, progressively change the name if
5851      applicable and use the matching DECL instead. */
5852   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5853     {
5854       char *separator;
5855       tree name = TYPE_NAME (class_type);
5856       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
5857
5858       strcpy (namebuffer, IDENTIFIER_POINTER (name));
5859
5860       do {
5861
5862        /* Reach the last '.', and if applicable, replace it by a `$' and
5863           see if this exists as a type. */
5864        if ((separator = strrchr (namebuffer, '.')))
5865          {
5866            *separator = '$';
5867            name = get_identifier (namebuffer);
5868            decl_result = IDENTIFIER_CLASS_VALUE (name);
5869          }
5870       } while (!decl_result && separator);
5871     }
5872   return decl_result;
5873 }
5874
5875 static tree
5876 qualify_and_find (tree class_type, tree package, tree name)
5877 {
5878   tree new_qualified = merge_qualified_name (package, name);
5879   tree new_class_decl;
5880
5881   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5882     load_class (new_qualified, 0);
5883   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5884     {
5885       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5886           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5887         load_class (new_qualified, 0);
5888       TYPE_NAME (class_type) = new_qualified;
5889       return IDENTIFIER_CLASS_VALUE (new_qualified);
5890     }
5891   return NULL_TREE;
5892 }
5893
5894 /* Resolve NAME and lay it out (if not done and if not the current
5895    parsed class). Return a decl node. This function is meant to be
5896    called when type resolution is necessary during the walk pass.  */
5897
5898 static tree
5899 resolve_and_layout (tree something, tree cl)
5900 {
5901   tree decl, decl_type;
5902
5903   /* Don't do that on the current class */
5904   if (something == current_class)
5905     return TYPE_NAME (current_class);
5906
5907   /* Don't do anything for void and other primitive types */
5908   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5909     return NULL_TREE;
5910
5911   /* Pointer types can be reall pointer types or fake pointers. When
5912      finding a real pointer, recheck for primitive types */
5913   if (TREE_CODE (something) == POINTER_TYPE)
5914     {
5915       if (TREE_TYPE (something))
5916         {
5917           something = TREE_TYPE (something);
5918           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5919             return NULL_TREE;
5920         }
5921       else
5922         something = TYPE_NAME (something);
5923     }
5924
5925   /* Don't do anything for arrays of primitive types */
5926   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5927       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5928     return NULL_TREE;
5929
5930   /* Something might be a WFL */
5931   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5932     something = EXPR_WFL_NODE (something);
5933
5934   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5935      TYPE_DECL or a real TYPE */
5936   else if (TREE_CODE (something) != IDENTIFIER_NODE)
5937     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5938             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5939
5940   if (!(decl = resolve_no_layout (something, cl)))
5941     return NULL_TREE;
5942
5943   /* Resolve and layout if necessary */
5944   decl_type = TREE_TYPE (decl);
5945   layout_class_methods (decl_type);
5946   /* Check methods */
5947   if (CLASS_FROM_SOURCE_P (decl_type))
5948     java_check_methods (decl);
5949   /* Layout the type if necessary */
5950   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5951     safe_layout_class (decl_type);
5952
5953   return decl;
5954 }
5955
5956 /* Resolve a class, returns its decl but doesn't perform any
5957    layout. The current parsing context is saved and restored */
5958
5959 static tree
5960 resolve_no_layout (tree name, tree cl)
5961 {
5962   tree ptr, decl;
5963   BUILD_PTR_FROM_NAME (ptr, name);
5964   java_parser_context_save_global ();
5965   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5966   java_parser_context_restore_global ();
5967
5968   return decl;
5969 }
5970
5971 /* Called when reporting errors. Skip the '[]'s in a complex array
5972    type description that failed to be resolved. purify_type_name can't
5973    use an identifier tree.  */
5974
5975 static const char *
5976 purify_type_name (const char *name)
5977 {
5978   int len = strlen (name);
5979   int bracket_found;
5980
5981   STRING_STRIP_BRACKETS (name, len, bracket_found);
5982   if (bracket_found)
5983     {
5984       char *stripped_name = xmemdup (name, len, len+1);
5985       stripped_name [len] = '\0';
5986       return stripped_name;
5987     }
5988   return name;
5989 }
5990
5991 /* The type CURRENT refers to can't be found. We print error messages.  */
5992
5993 static void
5994 complete_class_report_errors (jdep *dep)
5995 {
5996   const char *name;
5997
5998   if (!JDEP_WFL (dep))
5999     return;
6000
6001   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6002   switch (JDEP_KIND (dep))
6003     {
6004     case JDEP_SUPER:
6005       parse_error_context
6006         (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
6007          purify_type_name (name),
6008          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6009       break;
6010     case JDEP_FIELD:
6011       parse_error_context
6012         (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
6013          purify_type_name (name),
6014          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6015       break;
6016     case JDEP_METHOD:           /* Covers arguments */
6017       parse_error_context
6018         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
6019          purify_type_name (name),
6020          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6021          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6022       break;
6023     case JDEP_METHOD_RETURN:    /* Covers return type */
6024       parse_error_context
6025         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
6026          purify_type_name (name),
6027          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6028       break;
6029     case JDEP_INTERFACE:
6030       parse_error_context
6031         (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
6032          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6033          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6034          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6035       break;
6036     case JDEP_VARIABLE:
6037       parse_error_context
6038         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
6039          purify_type_name (IDENTIFIER_POINTER
6040                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6041          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6042       break;
6043     case JDEP_EXCEPTION:        /* As specified by `throws' */
6044       parse_error_context
6045           (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6046          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6047       break;
6048     default:
6049       /* Fix for -Wall. Just break doing nothing. The error will be
6050          caught later */
6051       break;
6052     }
6053 }
6054
6055 /* Return a static string containing the DECL prototype string. If
6056    DECL is a constructor, use the class name instead of the form
6057    <init> */
6058
6059 static const char *
6060 get_printable_method_name (tree decl)
6061 {
6062   const char *to_return;
6063   tree name = NULL_TREE;
6064
6065   if (DECL_CONSTRUCTOR_P (decl))
6066     {
6067       name = DECL_NAME (decl);
6068       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6069     }
6070
6071   to_return = lang_printable_name (decl, 0);
6072   if (DECL_CONSTRUCTOR_P (decl))
6073     DECL_NAME (decl) = name;
6074
6075   return to_return;
6076 }
6077
6078 /* Track method being redefined inside the same class. As a side
6079    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6080    function it's a FWL, so we can track errors more accurately.)  */
6081
6082 static int
6083 check_method_redefinition (tree class, tree method)
6084 {
6085   tree redef, sig;
6086
6087   /* There's no need to verify <clinit> and finit$ and instinit$ */
6088   if (DECL_CLINIT_P (method)
6089       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6090     return 0;
6091
6092   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6093   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6094     {
6095       if (redef == method)
6096         break;
6097       if (DECL_NAME (redef) == DECL_NAME (method)
6098           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6099           && !DECL_ARTIFICIAL (method))
6100         {
6101           parse_error_context
6102             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6103              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6104              get_printable_method_name (redef));
6105           return 1;
6106         }
6107     }
6108   return 0;
6109 }
6110
6111 /* Return 1 if check went ok, 0 otherwise.  */
6112 static int
6113 check_abstract_method_definitions (int do_interface, tree class_decl,
6114                                    tree type)
6115 {
6116   tree class = TREE_TYPE (class_decl);
6117   tree method, end_type;
6118   int ok = 1;
6119
6120   end_type = (do_interface ? object_type_node : type);
6121   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6122     {
6123       tree other_super, other_method, method_sig, method_name;
6124       int found = 0;
6125       int end_type_reached = 0;
6126
6127       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6128         continue;
6129
6130       /* Now verify that somewhere in between TYPE and CLASS,
6131          abstract method METHOD gets a non abstract definition
6132          that is inherited by CLASS.  */
6133
6134       method_sig = build_java_signature (TREE_TYPE (method));
6135       method_name = DECL_NAME (method);
6136       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6137         method_name = EXPR_WFL_NODE (method_name);
6138
6139       other_super = class;
6140       do {
6141         if (other_super == end_type)
6142           end_type_reached = 1;
6143
6144         /* Method search */
6145         for (other_method = TYPE_METHODS (other_super); other_method;
6146             other_method = TREE_CHAIN (other_method))
6147           {
6148             tree s = build_java_signature (TREE_TYPE (other_method));
6149             tree other_name = DECL_NAME (other_method);
6150
6151             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6152               other_name = EXPR_WFL_NODE (other_name);
6153             if (!DECL_CLINIT_P (other_method)
6154                 && !DECL_CONSTRUCTOR_P (other_method)
6155                 && method_name == other_name
6156                 && method_sig == s
6157                 && !METHOD_ABSTRACT (other_method))
6158              {
6159                found = 1;
6160                break;
6161              }
6162           }
6163         other_super = CLASSTYPE_SUPER (other_super);
6164       } while (!end_type_reached);
6165
6166       /* Report that abstract METHOD didn't find an implementation
6167          that CLASS can use. */
6168       if (!found)
6169         {
6170           char *t = xstrdup (lang_printable_name
6171                             (TREE_TYPE (TREE_TYPE (method)), 0));
6172           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6173
6174           parse_error_context
6175             (lookup_cl (class_decl),
6176              "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",
6177              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6178              t, lang_printable_name (method, 0),
6179              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6180               "interface" : "class"),
6181              IDENTIFIER_POINTER (ccn),
6182              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6183              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6184           ok = 0;
6185           free (t);
6186         }
6187     }
6188
6189   if (ok && do_interface)
6190     {
6191       /* Check for implemented interfaces. */
6192       int i;
6193       tree vector = TYPE_BINFO_BASETYPES (type);
6194       for (i = 1; ok && vector && i < TREE_VEC_LENGTH (vector); i++)
6195         {
6196           tree super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6197           ok = check_abstract_method_definitions (1, class_decl, super);
6198         }
6199     }
6200
6201   return ok;
6202 }
6203
6204 /* Check that CLASS_DECL somehow implements all inherited abstract
6205    methods.  */
6206
6207 static void
6208 java_check_abstract_method_definitions (tree class_decl)
6209 {
6210   tree class = TREE_TYPE (class_decl);
6211   tree super, vector;
6212   int i;
6213
6214   if (CLASS_ABSTRACT (class_decl))
6215     return;
6216
6217   /* Check for inherited types */
6218   super = class;
6219   do {
6220     super = CLASSTYPE_SUPER (super);
6221     check_abstract_method_definitions (0, class_decl, super);
6222   } while (super != object_type_node);
6223
6224   /* Check for implemented interfaces. */
6225   vector = TYPE_BINFO_BASETYPES (class);
6226   for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
6227     {
6228       super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6229       check_abstract_method_definitions (1, class_decl, super);
6230     }
6231 }
6232
6233 /* Check all the types method DECL uses and return 1 if all of them
6234    are now complete, 0 otherwise. This is used to check whether its
6235    safe to build a method signature or not.  */
6236
6237 static int
6238 check_method_types_complete (tree decl)
6239 {
6240   tree type = TREE_TYPE (decl);
6241   tree args;
6242
6243   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6244     return 0;
6245
6246   args = TYPE_ARG_TYPES (type);
6247   if (TREE_CODE (type) == METHOD_TYPE)
6248     args = TREE_CHAIN (args);
6249   for (; args != end_params_node; args = TREE_CHAIN (args))
6250     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6251       return 0;
6252
6253   return 1;
6254 }
6255
6256 /* Visible interface to check methods contained in CLASS_DECL */
6257
6258 void
6259 java_check_methods (tree class_decl)
6260 {
6261   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6262     return;
6263
6264   if (CLASS_INTERFACE (class_decl))
6265     java_check_abstract_methods (class_decl);
6266   else
6267     java_check_regular_methods (class_decl);
6268
6269   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6270 }
6271
6272 /* Like not_accessible_p, but doesn't refer to the current class at
6273    all.  */
6274 static bool
6275 hack_is_accessible_p (tree member, tree from_where)
6276 {
6277   int flags = get_access_flags_from_decl (member);
6278
6279   if (from_where == DECL_CONTEXT (member)
6280       || (flags & ACC_PUBLIC))
6281     return true;
6282
6283   if ((flags & ACC_PROTECTED))
6284     {
6285       if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6286         return true;
6287     }
6288
6289   if ((flags & ACC_PRIVATE))
6290     return false;
6291
6292   /* Package private, or protected.  */
6293   return in_same_package (TYPE_NAME (from_where),
6294                           TYPE_NAME (DECL_CONTEXT (member)));
6295 }
6296
6297 /* Check all the methods of CLASS_DECL. Methods are first completed
6298    then checked according to regular method existence rules.  If no
6299    constructor for CLASS_DECL were encountered, then build its
6300    declaration.  */
6301 static void
6302 java_check_regular_methods (tree class_decl)
6303 {
6304   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6305   tree method;
6306   tree class = TREE_TYPE (class_decl);
6307   tree found = NULL_TREE;
6308   tree mthrows;
6309
6310   /* It is not necessary to check methods defined in java.lang.Object */
6311   if (class == object_type_node)
6312     return;
6313
6314   if (!TYPE_NVIRTUALS (class))
6315     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6316
6317   /* Should take interfaces into account. FIXME */
6318   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6319     {
6320       tree sig;
6321       tree method_wfl = DECL_FUNCTION_WFL (method);
6322       int aflags;
6323
6324       /* Check for redefinitions */
6325       if (check_method_redefinition (class, method))
6326         continue;
6327
6328       /* We verify things thrown by the method.  They must inherit from
6329          java.lang.Throwable.  */
6330       for (mthrows = DECL_FUNCTION_THROWS (method);
6331            mthrows; mthrows = TREE_CHAIN (mthrows))
6332         {
6333           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6334             parse_error_context
6335               (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6336                IDENTIFIER_POINTER
6337                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6338         }
6339
6340       /* If we see one constructor a mark so we don't generate the
6341          default one.  Also skip other verifications: constructors
6342          can't be inherited hence hidden or overridden.  */
6343       if (DECL_CONSTRUCTOR_P (method))
6344         {
6345           saw_constructor = 1;
6346           continue;
6347         }
6348
6349       sig = build_java_argument_signature (TREE_TYPE (method));
6350       found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6351                                               SEARCH_SUPER | SEARCH_INTERFACE);
6352
6353       /* Inner class can't declare static methods */
6354       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6355         {
6356           char *t = xstrdup (lang_printable_name (class, 0));
6357           parse_error_context
6358             (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6359              lang_printable_name (method, 0), t);
6360           free (t);
6361         }
6362
6363       /* Nothing overrides or it's a private method. */
6364       if (!found)
6365         continue;
6366       if (METHOD_PRIVATE (found))
6367         {
6368           found = NULL_TREE;
6369           continue;
6370         }
6371
6372       /* If `found' is declared in an interface, make sure the
6373          modifier matches. */
6374       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6375           && clinit_identifier_node != DECL_NAME (found)
6376           && !METHOD_PUBLIC (method))
6377         {
6378           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6379           parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6380                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6381                                lang_printable_name (method, 0),
6382                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6383         }
6384
6385       /* Can't override a method with the same name and different return
6386          types. */
6387       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6388         {
6389           char *t = xstrdup
6390             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6391           parse_error_context
6392             (method_wfl,
6393              "Method `%s' was defined with return type `%s' in class `%s'",
6394              lang_printable_name (found, 0), t,
6395              IDENTIFIER_POINTER
6396                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6397           free (t);
6398         }
6399
6400       aflags = get_access_flags_from_decl (found);
6401
6402       /* Can't override final. Can't override static. */
6403       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6404         {
6405           /* Static *can* override static */
6406           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6407             continue;
6408           parse_error_context
6409             (method_wfl,
6410              "%s methods can't be overridden. Method `%s' is %s in class `%s'",
6411              (METHOD_FINAL (found) ? "Final" : "Static"),
6412              lang_printable_name (found, 0),
6413              (METHOD_FINAL (found) ? "final" : "static"),
6414              IDENTIFIER_POINTER
6415                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6416           continue;
6417         }
6418
6419       /* Static method can't override instance method. */
6420       if (METHOD_STATIC (method))
6421         {
6422           parse_error_context
6423             (method_wfl,
6424              "Instance methods can't be overridden by a static method. Method `%s' is an instance method in class `%s'",
6425              lang_printable_name (found, 0),
6426              IDENTIFIER_POINTER
6427                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6428           continue;
6429         }
6430
6431       /* - Overriding/hiding public must be public
6432          - Overriding/hiding protected must be protected or public
6433          - If the overridden or hidden method has default (package)
6434            access, then the overriding or hiding method must not be
6435            private; otherwise, a compile-time error occurs.  If
6436            `found' belongs to an interface, things have been already
6437            taken care of.  */
6438       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6439           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6440               || (METHOD_PROTECTED (found)
6441                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6442               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6443                   && METHOD_PRIVATE (method))))
6444         {
6445           parse_error_context
6446             (method_wfl,
6447              "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6448              (METHOD_PUBLIC (method) ? "public" :
6449               (METHOD_PRIVATE (method) ? "private" : "protected")),
6450              IDENTIFIER_POINTER (DECL_NAME
6451                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6452           continue;
6453         }
6454
6455       /* Check this method against all the other implementations it
6456          overrides.  Here we only check the class hierarchy; the rest
6457          of the checking is done later.  If this method is just a
6458          Miranda method, we can skip the check.  */
6459       if (! METHOD_INVISIBLE (method))
6460         check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6461     }
6462
6463   /* The above throws clause check only looked at superclasses.  Now
6464      we must also make sure that all methods declared in interfaces
6465      have compatible throws clauses.  FIXME: there are more efficient
6466      ways to organize this checking; we should implement one.  */
6467   check_interface_throws_clauses (class, class);
6468
6469   if (!TYPE_NVIRTUALS (class))
6470     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6471
6472   /* Search for inherited abstract method not yet implemented in this
6473      class.  */
6474   java_check_abstract_method_definitions (class_decl);
6475
6476   if (!saw_constructor)
6477     abort ();
6478 }
6479
6480 /* Check to make sure that all the methods in all the interfaces
6481    implemented by CLASS_DECL are compatible with the concrete
6482    implementations available in CHECK_CLASS_DECL.  */
6483 static void
6484 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6485 {
6486   for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6487     {
6488       tree bases = TYPE_BINFO_BASETYPES (class_decl);
6489       int iface_len = TREE_VEC_LENGTH (bases) - 1;
6490       int i;
6491
6492       for (i = iface_len; i > 0; --i)
6493         {
6494           tree interface = BINFO_TYPE (TREE_VEC_ELT (bases, i));
6495           tree iface_method;
6496
6497           for (iface_method = TYPE_METHODS (interface);
6498                iface_method != NULL_TREE;
6499                iface_method = TREE_CHAIN (iface_method))
6500             {
6501               tree sig, method;
6502
6503               /* First look for a concrete method implemented or
6504                  inherited by this class.  No need to search
6505                  interfaces here, since we're already looking through
6506                  all of them.  */
6507               sig = build_java_argument_signature (TREE_TYPE (iface_method));
6508               method
6509                 = lookup_argument_method_generic (check_class_decl,
6510                                                   DECL_NAME (iface_method),
6511                                                   sig, SEARCH_VISIBLE);
6512               /* If we don't find an implementation, that is ok.  Any
6513                  potential errors from that are diagnosed elsewhere.
6514                  Also, multiple inheritance with conflicting throws
6515                  clauses is fine in the absence of a concrete
6516                  implementation.  */
6517               if (method != NULL_TREE && !METHOD_ABSTRACT (method))
6518                 {
6519                   tree method_wfl = DECL_FUNCTION_WFL (method);
6520                   check_throws_clauses (method, method_wfl, iface_method);
6521                 }
6522             }
6523
6524           /* Now check superinterfaces.  */
6525           check_interface_throws_clauses (check_class_decl, interface);
6526         }
6527     }
6528 }
6529
6530 /* Check throws clauses of a method against the clauses of all the
6531    methods it overrides.  We do this by searching up the class
6532    hierarchy, examining all matching accessible methods.  */
6533 static void
6534 check_concrete_throws_clauses (tree class, tree self_method,
6535                                tree name, tree signature)
6536 {
6537   tree method = lookup_argument_method_generic (class, name, signature,
6538                                                 SEARCH_SUPER | SEARCH_VISIBLE);
6539   while (method != NULL_TREE)
6540     {
6541       if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6542         check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6543                               method);
6544
6545       method = lookup_argument_method_generic (DECL_CONTEXT (method),
6546                                                name, signature,
6547                                                SEARCH_SUPER | SEARCH_VISIBLE);
6548     }
6549 }
6550
6551 /* Generate an error if the `throws' clause of METHOD (if any) is
6552    incompatible with the `throws' clause of FOUND (if any).  */
6553 static void
6554 check_throws_clauses (tree method, tree method_wfl, tree found)
6555 {
6556   tree mthrows;
6557
6558   /* Can't check these things with class loaded from bytecode. FIXME */
6559   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6560     return;
6561
6562   for (mthrows = DECL_FUNCTION_THROWS (method);
6563        mthrows; mthrows = TREE_CHAIN (mthrows))
6564     {
6565       tree fthrows;
6566
6567       /* We don't verify unchecked expressions */
6568       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6569         continue;
6570       /* Checked expression must be compatible */
6571       for (fthrows = DECL_FUNCTION_THROWS (found);
6572            fthrows; fthrows = TREE_CHAIN (fthrows))
6573         {
6574           if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6575             break;
6576         }
6577       if (!fthrows)
6578         {
6579           parse_error_context
6580             (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'",
6581              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6582              lang_printable_name (found, 0),
6583              IDENTIFIER_POINTER
6584              (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6585         }
6586     }
6587 }
6588
6589 /* Check abstract method of interface INTERFACE */
6590 static void
6591 java_check_abstract_methods (tree interface_decl)
6592 {
6593   int i, n;
6594   tree method, basetype_vec, found;
6595   tree interface = TREE_TYPE (interface_decl);
6596
6597   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6598     {
6599       /* 2- Check for double definition inside the defining interface */
6600       if (check_method_redefinition (interface, method))
6601         continue;
6602
6603       /* 3- Overriding is OK as far as we preserve the return type.  */
6604       found = lookup_java_interface_method2 (interface, method);
6605       if (found)
6606         {
6607           char *t;
6608           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6609           parse_error_context
6610             (DECL_FUNCTION_WFL (found),
6611              "Method `%s' was defined with return type `%s' in class `%s'",
6612              lang_printable_name (found, 0), t,
6613              IDENTIFIER_POINTER
6614                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6615           free (t);
6616           continue;
6617         }
6618     }
6619
6620   /* 4- Inherited methods can't differ by their returned types */
6621   if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6622     return;
6623   n = TREE_VEC_LENGTH (basetype_vec);
6624   for (i = 0; i < n; i++)
6625     {
6626       tree sub_interface_method, sub_interface;
6627       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6628       if (!vec_elt)
6629         continue;
6630       sub_interface = BINFO_TYPE (vec_elt);
6631       for (sub_interface_method = TYPE_METHODS (sub_interface);
6632            sub_interface_method;
6633            sub_interface_method = TREE_CHAIN (sub_interface_method))
6634         {
6635           found = lookup_java_interface_method2 (interface,
6636                                                  sub_interface_method);
6637           if (found && (found != sub_interface_method))
6638             {
6639               parse_error_context
6640                 (lookup_cl (sub_interface_method),
6641                  "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6642                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6643                  lang_printable_name (found, 0),
6644                  IDENTIFIER_POINTER
6645                    (DECL_NAME (TYPE_NAME
6646                                (DECL_CONTEXT (sub_interface_method)))),
6647                  IDENTIFIER_POINTER
6648                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6649             }
6650         }
6651     }
6652 }
6653
6654 /* Lookup methods in interfaces using their name and partial
6655    signature. Return a matching method only if their types differ.  */
6656
6657 static tree
6658 lookup_java_interface_method2 (tree class, tree method_decl)
6659 {
6660   int i, n;
6661   tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6662
6663   if (!basetype_vec)
6664     return NULL_TREE;
6665
6666   n = TREE_VEC_LENGTH (basetype_vec);
6667   for (i = 0; i < n; i++)
6668     {
6669       tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6670       if ((BINFO_TYPE (vec_elt) != object_type_node)
6671           && (to_return =
6672               lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6673         return to_return;
6674     }
6675   for (i = 0; i < n; i++)
6676     {
6677       to_return = lookup_java_interface_method2
6678         (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6679       if (to_return)
6680         return to_return;
6681     }
6682
6683   return NULL_TREE;
6684 }
6685
6686 /* Lookup method using their name and partial signature. Return a
6687    matching method only if their types differ.  */
6688
6689 static tree
6690 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6691 {
6692   tree method, method_signature, method_name, method_type, name;
6693
6694   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6695   name = DECL_NAME (method_decl);
6696   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6697                  EXPR_WFL_NODE (name) : name);
6698   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6699
6700   while (clas != NULL_TREE)
6701     {
6702       for (method = TYPE_METHODS (clas);
6703            method != NULL_TREE;  method = TREE_CHAIN (method))
6704         {
6705           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6706           tree name = DECL_NAME (method);
6707           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6708                EXPR_WFL_NODE (name) : name) == method_name
6709               && method_sig == method_signature
6710               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6711             return method;
6712         }
6713       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6714     }
6715   return NULL_TREE;
6716 }
6717
6718 /* Return the line that matches DECL line number, and try its best to
6719    position the column number. Used during error reports.  */
6720
6721 static GTY(()) tree cl_v;
6722 static tree
6723 lookup_cl (tree decl)
6724 {
6725   char *line, *found;
6726
6727   if (!decl)
6728     return NULL_TREE;
6729
6730   if (cl_v == NULL_TREE)
6731     {
6732       cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6733     }
6734
6735   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6736   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6737
6738   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6739                             EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6740
6741   found = strstr ((const char *)line,
6742                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6743   if (found)
6744     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6745
6746   return cl_v;
6747 }
6748
6749 /* Look for a simple name in the single-type import list */
6750
6751 static tree
6752 find_name_in_single_imports (tree name)
6753 {
6754   tree node;
6755
6756   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6757     if (TREE_VALUE (node) == name)
6758       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6759
6760   return NULL_TREE;
6761 }
6762
6763 /* Process all single-type import. */
6764
6765 static int
6766 process_imports (void)
6767 {
6768   tree import;
6769   int error_found;
6770
6771   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6772     {
6773       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6774       char *original_name;
6775
6776       original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6777                                IDENTIFIER_LENGTH (to_be_found),
6778                                IDENTIFIER_LENGTH (to_be_found) + 1);
6779
6780       /* Don't load twice something already defined. */
6781       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6782         continue;
6783
6784       while (1)
6785         {
6786           tree left;
6787
6788           QUALIFIED_P (to_be_found) = 1;
6789           load_class (to_be_found, 0);
6790           error_found =
6791             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true);
6792
6793           /* We found it, we can bail out */
6794           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6795             {
6796               check_deprecation (TREE_PURPOSE (import),
6797                                  IDENTIFIER_CLASS_VALUE (to_be_found));
6798               break;
6799             }
6800
6801           /* We haven't found it. Maybe we're trying to access an
6802              inner class.  The only way for us to know is to try again
6803              after having dropped a qualifier. If we can't break it further,
6804              we have an error. */
6805           if (breakdown_qualified (&left, NULL, to_be_found))
6806             break;
6807
6808           to_be_found = left;
6809         }
6810       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6811         {
6812           parse_error_context (TREE_PURPOSE (import),
6813                                "Class or interface `%s' not found in import",
6814                                original_name);
6815           error_found = 1;
6816         }
6817
6818       free (original_name);
6819       if (error_found)
6820         return 1;
6821     }
6822   return 0;
6823 }
6824
6825 /* Possibly find and mark a class imported by a single-type import
6826    statement.  */
6827
6828 static void
6829 find_in_imports (tree enclosing_type, tree class_type)
6830 {
6831   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6832                  ctxp->import_list);
6833   while (import)
6834     {
6835       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6836         {
6837           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6838           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6839           return;
6840         }
6841       import = TREE_CHAIN (import);
6842     }
6843 }
6844
6845 static int
6846 note_possible_classname (const char *name, int len)
6847 {
6848   tree node;
6849   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6850     len = len - 5;
6851   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6852     len = len - 6;
6853   else
6854     return 0;
6855   node = ident_subst (name, len, "", '/', '.', "");
6856   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6857   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6858   return 1;
6859 }
6860
6861 /* Read a import directory, gathering potential match for further type
6862    references. Indifferently reads a filesystem or a ZIP archive
6863    directory.  */
6864
6865 static void
6866 read_import_dir (tree wfl)
6867 {
6868   tree package_id = EXPR_WFL_NODE (wfl);
6869   const char *package_name = IDENTIFIER_POINTER (package_id);
6870   int package_length = IDENTIFIER_LENGTH (package_id);
6871   DIR *dirp = NULL;
6872   JCF *saved_jcf = current_jcf;
6873
6874   int found = 0;
6875   int k;
6876   void *entry;
6877   struct buffer filename[1];
6878
6879   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6880     return;
6881   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6882
6883   BUFFER_INIT (filename);
6884   buffer_grow (filename, package_length + 100);
6885
6886   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6887     {
6888       const char *entry_name = jcf_path_name (entry);
6889       int entry_length = strlen (entry_name);
6890       if (jcf_path_is_zipfile (entry))
6891         {
6892           ZipFile *zipf;
6893           buffer_grow (filename, entry_length);
6894           memcpy (filename->data, entry_name, entry_length - 1);
6895           filename->data[entry_length-1] = '\0';
6896           zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6897           if (zipf == NULL)
6898             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6899           else
6900             {
6901               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6902               BUFFER_RESET (filename);
6903               for (k = 0; k < package_length; k++)
6904                 {
6905                   char ch = package_name[k];
6906                   *filename->ptr++ = ch == '.' ? '/' : ch;
6907                 }
6908               *filename->ptr++ = '/';
6909
6910               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
6911                 {
6912                   const char *current_entry = ZIPDIR_FILENAME (zipd);
6913                   int current_entry_len = zipd->filename_length;
6914
6915                   if (current_entry_len >= BUFFER_LENGTH (filename)
6916                       && strncmp (filename->data, current_entry,
6917                                   BUFFER_LENGTH (filename)) != 0)
6918                     continue;
6919                   found |= note_possible_classname (current_entry,
6920                                                     current_entry_len);
6921                 }
6922             }
6923         }
6924       else
6925         {
6926           BUFFER_RESET (filename);
6927           buffer_grow (filename, entry_length + package_length + 4);
6928           strcpy (filename->data, entry_name);
6929           filename->ptr = filename->data + entry_length;
6930           for (k = 0; k < package_length; k++)
6931             {
6932               char ch = package_name[k];
6933               *filename->ptr++ = ch == '.' ? '/' : ch;
6934             }
6935           *filename->ptr = '\0';
6936
6937           dirp = opendir (filename->data);
6938           if (dirp == NULL)
6939             continue;
6940           *filename->ptr++ = '/';
6941           for (;;)
6942             {
6943               int len;
6944               const char *d_name;
6945               struct dirent *direntp = readdir (dirp);
6946               if (!direntp)
6947                 break;
6948               d_name = direntp->d_name;
6949               len = strlen (direntp->d_name);
6950               buffer_grow (filename, len+1);
6951               strcpy (filename->ptr, d_name);
6952               found |= note_possible_classname (filename->data + entry_length,
6953                                                 package_length+len+1);
6954             }
6955           if (dirp)
6956             closedir (dirp);
6957         }
6958     }
6959
6960   free (filename->data);
6961
6962   /* Here we should have a unified way of retrieving an entry, to be
6963      indexed. */
6964   if (!found)
6965     {
6966       static int first = 1;
6967       if (first)
6968         {
6969           error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
6970           java_error_count++;
6971           first = 0;
6972         }
6973       else
6974         parse_error_context (wfl, "Package `%s' not found in import",
6975                              package_name);
6976       current_jcf = saved_jcf;
6977       return;
6978     }
6979   current_jcf = saved_jcf;
6980 }
6981
6982 /* Possibly find a type in the import on demands specified
6983    types. Returns 1 if an error occurred, 0 otherwise. Run through the
6984    entire list, to detected potential double definitions.  */
6985
6986 static int
6987 find_in_imports_on_demand (tree enclosing_type, tree class_type)
6988 {
6989   tree class_type_name = TYPE_NAME (class_type);
6990   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
6991                   ctxp->import_demand_list);
6992   tree cl = NULL_TREE;
6993   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
6994   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
6995   tree node;
6996
6997   for (; import; import = TREE_CHAIN (import))
6998     {
6999       int saved_lineno = input_line;
7000       int access_check;
7001       const char *id_name;
7002       tree decl, type_name_copy;
7003
7004       obstack_grow (&temporary_obstack,
7005                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
7006                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
7007       obstack_1grow (&temporary_obstack, '.');
7008       obstack_grow0 (&temporary_obstack,
7009                      IDENTIFIER_POINTER (class_type_name),
7010                      IDENTIFIER_LENGTH (class_type_name));
7011       id_name = obstack_finish (&temporary_obstack);
7012
7013       if (! (node = maybe_get_identifier (id_name)))
7014         continue;
7015
7016       /* Setup lineno so that it refers to the line of the import (in
7017          case we parse a class file and encounter errors */
7018       input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
7019
7020       type_name_copy = TYPE_NAME (class_type);
7021       TYPE_NAME (class_type) = node;
7022       QUALIFIED_P (node) = 1;
7023       decl = IDENTIFIER_CLASS_VALUE (node);
7024       access_check = -1;
7025       /* If there is no DECL set for the class or if the class isn't
7026          loaded and not seen in source yet, then load */
7027       if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
7028                     && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
7029         {
7030           load_class (node, 0);
7031           decl = IDENTIFIER_CLASS_VALUE (node);
7032         }
7033       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7034         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7035                                                false);
7036       else
7037         /* 6.6.1: Inner classes are subject to member access rules. */
7038         access_check = 0;
7039
7040       input_line = saved_lineno;
7041
7042       /* If the loaded class is not accessible or couldn't be loaded,
7043          we restore the original TYPE_NAME and process the next
7044          import. */
7045       if (access_check || !decl)
7046         {
7047           TYPE_NAME (class_type) = type_name_copy;
7048           continue;
7049         }
7050
7051       /* If the loaded class is accessible, we keep a tab on it to
7052          detect and report multiple inclusions. */
7053       if (IS_A_CLASSFILE_NAME (node))
7054         {
7055           if (seen_once < 0)
7056             {
7057               cl = TREE_PURPOSE (import);
7058               seen_once = 1;
7059             }
7060           else if (seen_once >= 0)
7061             {
7062               tree location = (cl ? cl : TREE_PURPOSE (import));
7063               tree package = (cl ? EXPR_WFL_NODE (cl) :
7064                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
7065               seen_once++;
7066               parse_error_context
7067                 (location,
7068                  "Type `%s' also potentially defined in package `%s'",
7069                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7070                  IDENTIFIER_POINTER (package));
7071             }
7072         }
7073       to_return = access_check;
7074     }
7075
7076   if (seen_once == 1)
7077     return to_return;
7078   else
7079     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7080 }
7081
7082 /* Add package NAME to the list of packages encountered so far. To
7083    speed up class lookup in do_resolve_class, we make sure a
7084    particular package is added only once.  */
7085
7086 static void
7087 register_package (tree name)
7088 {
7089   static htab_t pht;
7090   void **e;
7091
7092   if (pht == NULL)
7093     pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
7094
7095   e = htab_find_slot (pht, name, INSERT);
7096   if (*e == NULL)
7097     {
7098       package_list = chainon (package_list, build_tree_list (name, NULL));
7099       *e = name;
7100     }
7101 }
7102
7103 static tree
7104 resolve_package (tree pkg, tree *next, tree *type_name)
7105 {
7106   tree current;
7107   tree decl = NULL_TREE;
7108   *type_name = NULL_TREE;
7109
7110   /* The trick is to determine when the package name stops and were
7111      the name of something contained in the package starts. Then we
7112      return a fully qualified name of what we want to get. */
7113
7114   *next = EXPR_WFL_QUALIFICATION (pkg);
7115
7116   /* Try to progressively construct a type name */
7117   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7118     for (current = EXPR_WFL_QUALIFICATION (pkg);
7119          current; current = TREE_CHAIN (current))
7120       {
7121         /* If we don't have what we're expecting, exit now. TYPE_NAME
7122            will be null and the error caught later. */
7123         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7124           break;
7125         *type_name =
7126           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7127         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7128           {
7129             /* resolve_package should be used in a loop, hence we
7130                point at this one to naturally process the next one at
7131                the next iteration. */
7132             *next = current;
7133             break;
7134           }
7135       }
7136   return decl;
7137 }
7138
7139
7140 /* Check accessibility of inner classes according to member access rules.
7141    DECL is the inner class, ENCLOSING_DECL is the class from which the
7142    access is being attempted. */
7143
7144 static void
7145 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7146 {
7147   const char *access;
7148   tree enclosing_decl_type;
7149
7150   /* We don't issue an error message when CL is null. CL can be null
7151      as a result of processing a JDEP crafted by source_start_java_method
7152      for the purpose of patching its parm decl. But the error would
7153      have been already trapped when fixing the method's signature.
7154      DECL can also be NULL in case of earlier errors. */
7155   if (!decl || !cl)
7156     return;
7157
7158   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7159
7160   if (CLASS_PRIVATE (decl))
7161     {
7162       /* Access is permitted only within the body of the top-level
7163          class in which DECL is declared. */
7164       tree top_level = decl;
7165       while (DECL_CONTEXT (top_level))
7166         top_level = DECL_CONTEXT (top_level);
7167       while (DECL_CONTEXT (enclosing_decl))
7168         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7169       if (top_level == enclosing_decl)
7170         return;
7171       access = "private";
7172     }
7173   else if (CLASS_PROTECTED (decl))
7174     {
7175       tree decl_context;
7176       /* Access is permitted from within the same package... */
7177       if (in_same_package (decl, enclosing_decl))
7178         return;
7179
7180       /* ... or from within the body of a subtype of the context in which
7181          DECL is declared. */
7182       decl_context = DECL_CONTEXT (decl);
7183       while (enclosing_decl)
7184         {
7185           if (CLASS_INTERFACE (decl))
7186             {
7187               if (interface_of_p (TREE_TYPE (decl_context),
7188                                   enclosing_decl_type))
7189                 return;
7190             }
7191           else
7192             {
7193               /* Eww. The order of the arguments is different!! */
7194               if (inherits_from_p (enclosing_decl_type,
7195                                    TREE_TYPE (decl_context)))
7196                 return;
7197             }
7198           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7199         }
7200       access = "protected";
7201     }
7202   else if (! CLASS_PUBLIC (decl))
7203     {
7204       /* Access is permitted only from within the same package as DECL. */
7205       if (in_same_package (decl, enclosing_decl))
7206         return;
7207       access = "non-public";
7208     }
7209   else
7210     /* Class is public. */
7211     return;
7212
7213   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7214                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7215                        lang_printable_name (decl, 0), access);
7216 }
7217
7218 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7219    foreign package, it must be PUBLIC. Return 0 if no access
7220    violations were found, 1 otherwise. If VERBOSE is true and an error
7221    was found, it is reported and accounted for.  */
7222
7223 static int
7224 check_pkg_class_access (tree class_name, tree cl, bool verbose)
7225 {
7226   tree type;
7227
7228   if (!IDENTIFIER_CLASS_VALUE (class_name))
7229     return 0;
7230
7231   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7232     return 0;
7233
7234   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7235     {
7236       /* Access to a private class within the same package is
7237          allowed. */
7238       tree l, r;
7239       breakdown_qualified (&l, &r, class_name);
7240       if (!QUALIFIED_P (class_name) && !ctxp->package)
7241         /* Both in the empty package. */
7242         return 0;
7243       if (l == ctxp->package)
7244         /* Both in the same package. */
7245         return 0;
7246
7247       if (verbose)
7248         parse_error_context
7249           (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7250            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7251            IDENTIFIER_POINTER (class_name));
7252       return 1;
7253     }
7254   return 0;
7255 }
7256
7257 /* Local variable declaration. */
7258
7259 static void
7260 declare_local_variables (int modifier, tree type, tree vlist)
7261 {
7262   tree decl, current, saved_type;
7263   tree type_wfl = NULL_TREE;
7264   int must_chain = 0;
7265   int final_p = 0;
7266
7267   /* Push a new block if statements were seen between the last time we
7268      pushed a block and now. Keep a count of blocks to close */
7269   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7270     {
7271       tree b = enter_block ();
7272       BLOCK_IS_IMPLICIT (b) = 1;
7273     }
7274
7275   if (modifier)
7276     {
7277       size_t i;
7278       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7279         if (1 << i & modifier)
7280           break;
7281       if (modifier == ACC_FINAL)
7282         final_p = 1;
7283       else
7284         {
7285           parse_error_context
7286             (ctxp->modifier_ctx [i],
7287              "Only `final' is allowed as a local variables modifier");
7288           return;
7289         }
7290     }
7291
7292   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7293      hold the TYPE value if a new incomplete has to be created (as
7294      opposed to being found already existing and reused). */
7295   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7296
7297   /* If TYPE is fully resolved and we don't have a reference, make one */
7298   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7299
7300   /* Go through all the declared variables */
7301   for (current = vlist, saved_type = type; current;
7302        current = TREE_CHAIN (current), type = saved_type)
7303     {
7304       tree other, real_type;
7305       tree wfl  = TREE_PURPOSE (current);
7306       tree name = EXPR_WFL_NODE (wfl);
7307       tree init = TREE_VALUE (current);
7308
7309       /* Process NAME, as it may specify extra dimension(s) for it */
7310       type = build_array_from_name (type, type_wfl, name, &name);
7311
7312       /* Variable redefinition check */
7313       if ((other = lookup_name_in_blocks (name)))
7314         {
7315           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7316                                        DECL_SOURCE_LINE (other));
7317           continue;
7318         }
7319
7320       /* Type adjustment. We may have just readjusted TYPE because
7321          the variable specified more dimensions. Make sure we have
7322          a reference if we can and don't have one already. */
7323       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7324
7325       real_type = GET_REAL_TYPE (type);
7326       /* Never layout this decl. This will be done when its scope
7327          will be entered */
7328       decl = build_decl (VAR_DECL, name, real_type);
7329       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7330       DECL_FINAL (decl) = final_p;
7331       BLOCK_CHAIN_DECL (decl);
7332
7333       /* If doing xreferencing, replace the line number with the WFL
7334          compound value */
7335       if (flag_emit_xref)
7336         DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7337
7338       /* Don't try to use an INIT statement when an error was found */
7339       if (init && java_error_count)
7340         init = NULL_TREE;
7341
7342       /* Add the initialization function to the current function's code */
7343       if (init)
7344         {
7345           /* Name might have been readjusted */
7346           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7347           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7348           java_method_add_stmt (current_function_decl,
7349                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7350                                                       init));
7351         }
7352
7353       /* Setup dependency the type of the decl */
7354       if (must_chain)
7355         {
7356           jdep *dep;
7357           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7358           dep = CLASSD_LAST (ctxp->classd_list);
7359           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7360         }
7361     }
7362   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7363 }
7364
7365 /* Called during parsing. Build decls from argument list.  */
7366
7367 static void
7368 source_start_java_method (tree fndecl)
7369 {
7370   tree tem;
7371   tree parm_decl;
7372   int i;
7373
7374   if (!fndecl)
7375     return;
7376
7377   current_function_decl = fndecl;
7378
7379   /* New scope for the function */
7380   enter_block ();
7381   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7382        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7383     {
7384       tree type = TREE_VALUE (tem);
7385       tree name = TREE_PURPOSE (tem);
7386
7387       /* If type is incomplete. Create an incomplete decl and ask for
7388          the decl to be patched later */
7389       if (INCOMPLETE_TYPE_P (type))
7390         {
7391           jdep *jdep;
7392           tree real_type = GET_REAL_TYPE (type);
7393           parm_decl = build_decl (PARM_DECL, name, real_type);
7394           type = obtain_incomplete_type (type);
7395           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7396           jdep = CLASSD_LAST (ctxp->classd_list);
7397           JDEP_MISC (jdep) = name;
7398           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7399         }
7400       else
7401         parm_decl = build_decl (PARM_DECL, name, type);
7402
7403       /* Remember if a local variable was declared final (via its
7404          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7405       if (ARG_FINAL_P (tem))
7406         {
7407           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7408           DECL_FINAL (parm_decl) = 1;
7409         }
7410
7411       BLOCK_CHAIN_DECL (parm_decl);
7412     }
7413   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7414   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7415     nreverse (tem);
7416   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7417   DECL_MAX_LOCALS (current_function_decl) = i;
7418 }
7419
7420 /* Called during parsing. Creates an artificial method declaration.  */
7421
7422 static tree
7423 create_artificial_method (tree class, int flags, tree type,
7424                           tree name, tree args)
7425 {
7426   tree mdecl;
7427
7428   java_parser_context_save_global ();
7429   input_line = 0;
7430   mdecl = make_node (FUNCTION_TYPE);
7431   TREE_TYPE (mdecl) = type;
7432   TYPE_ARG_TYPES (mdecl) = args;
7433   mdecl = add_method (class, flags, name, build_java_signature (mdecl));
7434   java_parser_context_restore_global ();
7435   DECL_ARTIFICIAL (mdecl) = 1;
7436   return mdecl;
7437 }
7438
7439 /* Starts the body if an artificial method.  */
7440
7441 static void
7442 start_artificial_method_body (tree mdecl)
7443 {
7444   DECL_SOURCE_LINE (mdecl) = 1;
7445   DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7446   source_start_java_method (mdecl);
7447   enter_block ();
7448 }
7449
7450 static void
7451 end_artificial_method_body (tree mdecl)
7452 {
7453   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7454      It has to be evaluated first. (if mdecl is current_function_decl,
7455      we have an undefined behavior if no temporary variable is used.) */
7456   tree b = exit_block ();
7457   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7458   exit_block ();
7459 }
7460
7461 /* Dump a tree of some kind.  This is a convenience wrapper for the
7462    dump_* functions in tree-dump.c.  */
7463 static void
7464 dump_java_tree (enum tree_dump_index phase, tree t)
7465 {
7466   FILE *stream;
7467   int flags;
7468
7469   stream = dump_begin (phase, &flags);
7470   flags |= TDF_SLIM;
7471   if (stream)
7472     {
7473       dump_node (t, flags, stream);
7474       dump_end (phase, stream);
7475     }
7476 }
7477
7478 /* Terminate a function and expand its body.  */
7479
7480 static void
7481 source_end_java_method (void)
7482 {
7483   tree fndecl = current_function_decl;
7484
7485   if (!fndecl)
7486     return;
7487
7488   java_parser_context_save_global ();
7489   input_line = ctxp->last_ccb_indent1;
7490
7491   /* Turn function bodies with only a NOP expr null, so they don't get
7492      generated at all and we won't get warnings when using the -W
7493      -Wall flags. */
7494   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
7495     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7496
7497   /* We've generated all the trees for this function, and it has been
7498      patched.  Dump it to a file if the user requested it.  */
7499   dump_java_tree (TDI_original, fndecl);
7500
7501   /* Defer expanding the method until cgraph analysis is complete.  */
7502   if (DECL_SAVED_TREE (fndecl))
7503     cgraph_finalize_function (fndecl, false);
7504
7505   current_function_decl = NULL_TREE;
7506   java_parser_context_restore_global ();
7507 }
7508
7509 /* Record EXPR in the current function block. Complements compound
7510    expression second operand if necessary.  */
7511
7512 tree
7513 java_method_add_stmt (tree fndecl, tree expr)
7514 {
7515   if (!GET_CURRENT_BLOCK (fndecl))
7516     return NULL_TREE;
7517   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7518 }
7519
7520 static tree
7521 add_stmt_to_block (tree b, tree type, tree stmt)
7522 {
7523   tree body = BLOCK_EXPR_BODY (b), c;
7524
7525   if (java_error_count)
7526     return body;
7527
7528   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7529     return body;
7530
7531   BLOCK_EXPR_BODY (b) = c;
7532   TREE_SIDE_EFFECTS (c) = 1;
7533   return c;
7534 }
7535
7536 /* Add STMT to EXISTING if possible, otherwise create a new
7537    COMPOUND_EXPR and add STMT to it. */
7538
7539 static tree
7540 add_stmt_to_compound (tree existing, tree type, tree stmt)
7541 {
7542   if (existing)
7543     return build (COMPOUND_EXPR, type, existing, stmt);
7544   else
7545     return stmt;
7546 }
7547
7548 void java_layout_seen_class_methods (void)
7549 {
7550   tree previous_list = all_class_list;
7551   tree end = NULL_TREE;
7552   tree current;
7553
7554   while (1)
7555     {
7556       for (current = previous_list;
7557            current != end; current = TREE_CHAIN (current))
7558         layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
7559
7560       if (previous_list != all_class_list)
7561         {
7562           end = previous_list;
7563           previous_list = all_class_list;
7564         }
7565       else
7566         break;
7567     }
7568 }
7569
7570 static GTY(()) tree stop_reordering;
7571 void
7572 java_reorder_fields (void)
7573 {
7574   tree current;
7575
7576   for (current = gclass_list; current; current = TREE_CHAIN (current))
7577     {
7578       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7579
7580       if (current_class == stop_reordering)
7581         break;
7582
7583       /* Reverse the fields, but leave the dummy field in front.
7584          Fields are already ordered for Object and Class */
7585       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7586           && current_class != class_type_node)
7587       {
7588         /* If the dummy field is there, reverse the right fields and
7589            just layout the type for proper fields offset */
7590         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7591           {
7592             tree fields = TYPE_FIELDS (current_class);
7593             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7594             TYPE_SIZE (current_class) = NULL_TREE;
7595           }
7596         /* We don't have a dummy field, we need to layout the class,
7597            after having reversed the fields */
7598         else
7599           {
7600             TYPE_FIELDS (current_class) =
7601               nreverse (TYPE_FIELDS (current_class));
7602             TYPE_SIZE (current_class) = NULL_TREE;
7603           }
7604       }
7605     }
7606   /* There are cases were gclass_list will be empty. */
7607   if (gclass_list)
7608     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7609 }
7610
7611 /* Layout the methods of all classes loaded in one way or another.
7612    Check methods of source parsed classes. Then reorder the
7613    fields and layout the classes or the type of all source parsed
7614    classes */
7615
7616 void
7617 java_layout_classes (void)
7618 {
7619   tree current;
7620   int save_error_count = java_error_count;
7621
7622   /* Layout the methods of all classes seen so far */
7623   java_layout_seen_class_methods ();
7624   java_parse_abort_on_error ();
7625   all_class_list = NULL_TREE;
7626
7627   /* Then check the methods of all parsed classes */
7628   for (current = gclass_list; current; current = TREE_CHAIN (current))
7629     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7630       java_check_methods (TREE_VALUE (current));
7631   java_parse_abort_on_error ();
7632
7633   for (current = gclass_list; current; current = TREE_CHAIN (current))
7634     {
7635       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7636       layout_class (current_class);
7637
7638       /* Error reported by the caller */
7639       if (java_error_count)
7640         return;
7641     }
7642
7643   /* We might have reloaded classes durign the process of laying out
7644      classes for code generation. We must layout the methods of those
7645      late additions, as constructor checks might use them */
7646   java_layout_seen_class_methods ();
7647   java_parse_abort_on_error ();
7648 }
7649
7650 /* Expand methods in the current set of classes remembered for
7651    generation.  */
7652
7653 static void
7654 java_complete_expand_classes (void)
7655 {
7656   tree current;
7657
7658   do_not_fold = flag_emit_xref;
7659
7660   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7661     if (!INNER_CLASS_DECL_P (current))
7662       java_complete_expand_class (current);
7663 }
7664
7665 /* Expand the methods found in OUTER, starting first by OUTER's inner
7666    classes, if any.  */
7667
7668 static void
7669 java_complete_expand_class (tree outer)
7670 {
7671   tree inner_list;
7672
7673   set_nested_class_simple_name_value (outer, 1); /* Set */
7674
7675   /* We need to go after all inner classes and start expanding them,
7676      starting with most nested ones. We have to do that because nested
7677      classes might add functions to outer classes */
7678
7679   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7680        inner_list; inner_list = TREE_CHAIN (inner_list))
7681     java_complete_expand_class (TREE_PURPOSE (inner_list));
7682
7683   java_complete_expand_methods (outer);
7684   set_nested_class_simple_name_value (outer, 0); /* Reset */
7685 }
7686
7687 /* Expand methods registered in CLASS_DECL. The general idea is that
7688    we expand regular methods first. This allows us get an estimate on
7689    how outer context local alias fields are really used so we can add
7690    to the constructor just enough code to initialize them properly (it
7691    also lets us generate finit$ correctly.) Then we expand the
7692    constructors and then <clinit>.  */
7693
7694 static void
7695 java_complete_expand_methods (tree class_decl)
7696 {
7697   tree clinit, decl, first_decl;
7698
7699   output_class = current_class = TREE_TYPE (class_decl);
7700
7701   /* Pre-expand <clinit> to figure whether we really need it or
7702      not. If we do need it, we pre-expand the static fields so they're
7703      ready to be used somewhere else. <clinit> will be fully expanded
7704      after we processed the constructors. */
7705   first_decl = TYPE_METHODS (current_class);
7706   clinit = maybe_generate_pre_expand_clinit (current_class);
7707
7708   /* Then generate finit$ (if we need to) because constructors will
7709    try to use it.*/
7710   if (TYPE_FINIT_STMT_LIST (current_class))
7711     java_complete_expand_method (generate_finit (current_class));
7712
7713   /* Then generate instinit$ (if we need to) because constructors will
7714      try to use it. */
7715   if (TYPE_II_STMT_LIST (current_class))
7716     java_complete_expand_method (generate_instinit (current_class));
7717
7718   /* Now do the constructors */
7719   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7720     {
7721       int no_body;
7722
7723       if (!DECL_CONSTRUCTOR_P (decl))
7724         continue;
7725
7726       no_body = !DECL_FUNCTION_BODY (decl);
7727       /* Don't generate debug info on line zero when expanding a
7728          generated constructor. */
7729       if (no_body)
7730         restore_line_number_status (1);
7731
7732       java_complete_expand_method (decl);
7733
7734       if (no_body)
7735         restore_line_number_status (0);
7736     }
7737
7738   /* First, do the ordinary methods. */
7739   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7740     {
7741       /* Ctors aren't part of this batch. */
7742       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7743         continue;
7744
7745       /* Skip abstract or native methods -- but do handle native
7746          methods when generating JNI stubs.  */
7747       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7748         {
7749           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7750           continue;
7751         }
7752
7753       if (METHOD_NATIVE (decl))
7754         {
7755           tree body;
7756           current_function_decl = decl;
7757           body = build_jni_stub (decl);
7758           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7759         }
7760
7761       java_complete_expand_method (decl);
7762     }
7763
7764   /* If there is indeed a <clinit>, fully expand it now */
7765   if (clinit)
7766     {
7767       /* Prevent the use of `this' inside <clinit> */
7768       ctxp->explicit_constructor_p = 1;
7769       java_complete_expand_method (clinit);
7770       ctxp->explicit_constructor_p = 0;
7771     }
7772
7773   /* We might have generated a class$ that we now want to expand */
7774   if (TYPE_DOT_CLASS (current_class))
7775     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7776
7777   /* Now verify constructor circularity (stop after the first one we
7778      prove wrong.) */
7779   if (!CLASS_INTERFACE (class_decl))
7780     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7781       if (DECL_CONSTRUCTOR_P (decl)
7782           && verify_constructor_circularity (decl, decl))
7783         break;
7784 }
7785
7786 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7787    safely used in some other methods/constructors.  */
7788
7789 static tree
7790 maybe_generate_pre_expand_clinit (tree class_type)
7791 {
7792   tree current, mdecl;
7793
7794   if (!TYPE_CLINIT_STMT_LIST (class_type))
7795     return NULL_TREE;
7796
7797   /* Go through all static fields and pre expand them */
7798   for (current = TYPE_FIELDS (class_type); current;
7799        current = TREE_CHAIN (current))
7800     if (FIELD_STATIC (current))
7801       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7802
7803   /* Then build the <clinit> method */
7804   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7805                                     clinit_identifier_node, end_params_node);
7806   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7807                        mdecl, NULL_TREE);
7808   start_artificial_method_body (mdecl);
7809
7810   /* We process the list of assignment we produced as the result of
7811      the declaration of initialized static field and add them as
7812      statement to the <clinit> method. */
7813   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7814        current = TREE_CHAIN (current))
7815     {
7816       tree stmt = current;
7817       /* We build the assignment expression that will initialize the
7818          field to its value. There are strict rules on static
7819          initializers (8.5). FIXME */
7820       if (TREE_CODE (stmt) != BLOCK && stmt != empty_stmt_node)
7821         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7822       java_method_add_stmt (mdecl, stmt);
7823     }
7824
7825   end_artificial_method_body (mdecl);
7826
7827   /* Now we want to place <clinit> as the last method (because we need
7828      it at least for interface so that it doesn't interfere with the
7829      dispatch table based lookup. */
7830   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7831     {
7832       current = TREE_CHAIN (TYPE_METHODS (class_type));
7833       TYPE_METHODS (class_type) = current;
7834
7835       while (TREE_CHAIN (current))
7836         current = TREE_CHAIN (current);
7837
7838       TREE_CHAIN (current) = mdecl;
7839       TREE_CHAIN (mdecl) = NULL_TREE;
7840     }
7841
7842   return mdecl;
7843 }
7844
7845 /* Analyzes a method body and look for something that isn't a
7846    MODIFY_EXPR with a constant value.  */
7847
7848 static int
7849 analyze_clinit_body (tree this_class, tree bbody)
7850 {
7851   while (bbody)
7852     switch (TREE_CODE (bbody))
7853       {
7854       case BLOCK:
7855         bbody = BLOCK_EXPR_BODY (bbody);
7856         break;
7857
7858       case EXPR_WITH_FILE_LOCATION:
7859         bbody = EXPR_WFL_NODE (bbody);
7860         break;
7861
7862       case COMPOUND_EXPR:
7863         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
7864           return 1;
7865         bbody = TREE_OPERAND (bbody, 1);
7866         break;
7867
7868       case MODIFY_EXPR:
7869         /* If we're generating to class file and we're dealing with an
7870            array initialization, we return 1 to keep <clinit> */
7871         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
7872             && flag_emit_class_files)
7873           return 1;
7874
7875         /* There are a few cases where we're required to keep
7876            <clinit>:
7877            - If this is an assignment whose operand is not constant,
7878            - If this is an assignment to a non-initialized field,
7879            - If this field is not a member of the current class.
7880         */
7881         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
7882                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
7883                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
7884
7885       default:
7886         return 1;
7887       }
7888   return 0;
7889 }
7890
7891
7892 /* See whether we could get rid of <clinit>. Criteria are: all static
7893    final fields have constant initial values and the body of <clinit>
7894    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7895
7896 static int
7897 maybe_yank_clinit (tree mdecl)
7898 {
7899   tree type, current;
7900   tree fbody, bbody;
7901
7902   if (!DECL_CLINIT_P (mdecl))
7903     return 0;
7904
7905   /* If the body isn't empty, then we keep <clinit>. Note that if
7906      we're emitting classfiles, this isn't enough not to rule it
7907      out. */
7908   fbody = DECL_FUNCTION_BODY (mdecl);
7909   bbody = BLOCK_EXPR_BODY (fbody);
7910   if (bbody && bbody != error_mark_node)
7911     bbody = BLOCK_EXPR_BODY (bbody);
7912   else
7913     return 0;
7914   if (bbody && ! flag_emit_class_files && bbody != empty_stmt_node)
7915     return 0;
7916
7917   type = DECL_CONTEXT (mdecl);
7918   current = TYPE_FIELDS (type);
7919
7920   for (current = (current ? TREE_CHAIN (current) : current);
7921        current; current = TREE_CHAIN (current))
7922     {
7923       tree f_init;
7924
7925       /* We're not interested in non-static fields.  */
7926       if (!FIELD_STATIC (current))
7927         continue;
7928
7929       /* Nor in fields without initializers. */
7930       f_init = DECL_INITIAL (current);
7931       if (f_init == NULL_TREE)
7932         continue;
7933
7934       /* Anything that isn't String or a basic type is ruled out -- or
7935          if we know how to deal with it (when doing things natively) we
7936          should generated an empty <clinit> so that SUID are computed
7937          correctly. */
7938       if (! JSTRING_TYPE_P (TREE_TYPE (current))
7939           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
7940         return 0;
7941
7942       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
7943         return 0;
7944     }
7945
7946   /* Now we analyze the method body and look for something that
7947      isn't a MODIFY_EXPR */
7948   if (bbody != empty_stmt_node && analyze_clinit_body (type, bbody))
7949     return 0;
7950
7951   /* Get rid of <clinit> in the class' list of methods */
7952   if (TYPE_METHODS (type) == mdecl)
7953     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7954   else
7955     for (current = TYPE_METHODS (type); current;
7956          current = TREE_CHAIN (current))
7957       if (TREE_CHAIN (current) == mdecl)
7958         {
7959           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7960           break;
7961         }
7962
7963   return 1;
7964 }
7965
7966 /* Install the argument from MDECL. Suitable to completion and
7967    expansion of mdecl's body.  */
7968
7969 void
7970 start_complete_expand_method (tree mdecl)
7971 {
7972   tree tem;
7973
7974   pushlevel (1);                /* Prepare for a parameter push */
7975   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7976   DECL_ARGUMENTS (mdecl) = tem;
7977
7978   for (; tem; tem = TREE_CHAIN (tem))
7979     {
7980       /* TREE_CHAIN (tem) will change after pushdecl. */
7981       tree next = TREE_CHAIN (tem);
7982       tree type = TREE_TYPE (tem);
7983       if (PROMOTE_PROTOTYPES
7984           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
7985           && INTEGRAL_TYPE_P (type))
7986         type = integer_type_node;
7987       DECL_ARG_TYPE (tem) = type;
7988       layout_decl (tem, 0);
7989       pushdecl (tem);
7990       /* Re-install the next so that the list is kept and the loop
7991          advances. */
7992       TREE_CHAIN (tem) = next;
7993     }
7994   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
7995   input_line = DECL_SOURCE_LINE (mdecl);
7996   build_result_decl (mdecl);
7997 }
7998
7999
8000 /* Complete and expand a method.  */
8001
8002 static void
8003 java_complete_expand_method (tree mdecl)
8004 {
8005   tree fbody, block_body, exception_copy;
8006
8007   current_function_decl = mdecl;
8008   /* Fix constructors before expanding them */
8009   if (DECL_CONSTRUCTOR_P (mdecl))
8010     fix_constructors (mdecl);
8011
8012   /* Expand functions that have a body */
8013   if (!DECL_FUNCTION_BODY (mdecl))
8014     return;
8015
8016   fbody = DECL_FUNCTION_BODY (mdecl);
8017   block_body = BLOCK_EXPR_BODY (fbody);
8018   exception_copy = NULL_TREE;
8019
8020   current_function_decl = mdecl;
8021
8022   if (! quiet_flag)
8023     fprintf (stderr, " [%s.",
8024              lang_printable_name (DECL_CONTEXT (mdecl), 0));
8025   announce_function (mdecl);
8026   if (! quiet_flag)
8027     fprintf (stderr, "]");
8028
8029   /* Prepare the function for tree completion */
8030   start_complete_expand_method (mdecl);
8031
8032   /* Install the current this */
8033   current_this = (!METHOD_STATIC (mdecl) ?
8034                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8035
8036   /* Purge the `throws' list of unchecked exceptions (we save a copy
8037      of the list and re-install it later.) */
8038   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8039   purge_unchecked_exceptions (mdecl);
8040
8041   /* Install exceptions thrown with `throws' */
8042   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8043
8044   if (block_body != NULL_TREE)
8045     {
8046       block_body = java_complete_tree (block_body);
8047
8048       /* Before we check initialization, attached all class initialization
8049          variable to the block_body */
8050       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8051                      attach_init_test_initialization_flags, block_body);
8052
8053       if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
8054         {
8055           check_for_initialization (block_body, mdecl);
8056
8057           /* Go through all the flags marking the initialization of
8058              static variables and see whether they're definitively
8059              assigned, in which case the type is remembered as
8060              definitively initialized in MDECL. */
8061           if (STATIC_CLASS_INIT_OPT_P ())
8062             {
8063               /* Always register the context as properly initialized in
8064                  MDECL. This used with caution helps removing extra
8065                  initialization of self. */
8066               if (METHOD_STATIC (mdecl))
8067                 {
8068                   *(htab_find_slot
8069                     (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8070                      DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8071                 }
8072             }
8073         }
8074       ctxp->explicit_constructor_p = 0;
8075     }
8076
8077   BLOCK_EXPR_BODY (fbody) = block_body;
8078
8079   /* If we saw a return but couldn't evaluate it properly, we'll have
8080      an error_mark_node here. */
8081   if (block_body != error_mark_node
8082       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8083       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
8084       && !flag_emit_xref)
8085     missing_return_error (current_function_decl);
8086
8087   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8088   maybe_yank_clinit (mdecl);
8089
8090   /* Pop the current level, with special measures if we found errors. */
8091   if (java_error_count)
8092     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8093   poplevel (1, 0, 1);
8094
8095   /* Pop the exceptions and sanity check */
8096   POP_EXCEPTIONS();
8097   if (currently_caught_type_list)
8098     abort ();
8099
8100   /* Restore the copy of the list of exceptions if emitting xrefs. */
8101   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8102 }
8103
8104 /* For with each class for which there's code to generate. */
8105
8106 static void
8107 java_expand_method_bodies (tree class)
8108 {
8109   tree decl;
8110   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8111     {
8112       tree block;
8113       tree body;
8114
8115       if (! DECL_FUNCTION_BODY (decl))
8116         continue;
8117
8118       current_function_decl = decl;
8119
8120       block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8121
8122       if (TREE_CODE (block) != BLOCK)
8123         abort ();
8124
8125       /* Save the function body for inlining.  */
8126       DECL_SAVED_TREE (decl) = block;
8127
8128       body = BLOCK_EXPR_BODY (block);
8129
8130       if (TREE_TYPE (body) == NULL_TREE)
8131         abort ();
8132
8133       /* It's time to assign the variable flagging static class
8134          initialization based on which classes invoked static methods
8135          are definitely initializing. This should be flagged. */
8136       if (STATIC_CLASS_INIT_OPT_P ())
8137         {
8138           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8139           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8140             {
8141               /* Executed for each statement calling a static function.
8142                  LIST is a TREE_LIST whose PURPOSE is the called function
8143                  and VALUE is a compound whose second operand can be patched
8144                  with static class initialization flag assignments.  */
8145
8146               tree called_method = TREE_PURPOSE (list);
8147               tree compound = TREE_VALUE (list);
8148               tree assignment_compound_list
8149                 = build_tree_list (called_method, NULL);
8150
8151               /* For each class definitely initialized in
8152                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8153                  assignment to the class initialization flag. */
8154               htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8155                              emit_test_initialization,
8156                              assignment_compound_list);
8157
8158               if (TREE_VALUE (assignment_compound_list))
8159                 TREE_OPERAND (compound, 1)
8160                   = TREE_VALUE (assignment_compound_list);
8161             }
8162         }
8163
8164       /* Prepend class initialization to static methods.  */
8165       if (METHOD_STATIC (decl) && ! METHOD_PRIVATE (decl)
8166           && ! flag_emit_class_files
8167           && ! DECL_CLINIT_P (decl)
8168           && ! CLASS_INTERFACE (TYPE_NAME (class)))
8169         {
8170           tree init = build (CALL_EXPR, void_type_node,
8171                              build_address_of (soft_initclass_node),
8172                              build_tree_list (NULL_TREE,
8173                                               build_class_ref (class)),
8174                              NULL_TREE);
8175           TREE_SIDE_EFFECTS (init) = 1;
8176           body = build (COMPOUND_EXPR, TREE_TYPE (body), init, body);
8177           BLOCK_EXPR_BODY (block) = body;
8178         }
8179
8180       /* Wrap synchronized method bodies in a monitorenter
8181          plus monitorexit cleanup.  */
8182       if (METHOD_SYNCHRONIZED (decl) && ! flag_emit_class_files)
8183         {
8184           tree enter, exit, lock;
8185           if (METHOD_STATIC (decl))
8186             lock = build_class_ref (class);
8187           else
8188             lock = DECL_ARGUMENTS (decl);
8189           BUILD_MONITOR_ENTER (enter, lock);
8190           BUILD_MONITOR_EXIT (exit, lock);
8191
8192           body = build (COMPOUND_EXPR, void_type_node,
8193                         enter,
8194                         build (TRY_FINALLY_EXPR, void_type_node, body, exit));
8195           BLOCK_EXPR_BODY (block) = body;
8196         }
8197
8198       /* Expand the the function body.  */
8199       source_end_java_method ();
8200     }
8201 }
8202
8203 \f
8204
8205 /* This section of the code deals with accessing enclosing context
8206    fields either directly by using the relevant access to this$<n> or
8207    by invoking an access method crafted for that purpose.  */
8208
8209 /* Build the necessary access from an inner class to an outer
8210    class. This routine could be optimized to cache previous result
8211    (decl, current_class and returned access).  When an access method
8212    needs to be generated, it always takes the form of a read. It might
8213    be later turned into a write by calling outer_field_access_fix.  */
8214
8215 static tree
8216 build_outer_field_access (tree id, tree decl)
8217 {
8218   tree access = NULL_TREE;
8219   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8220   tree decl_ctx = DECL_CONTEXT (decl);
8221
8222   /* If the immediate enclosing context of the current class is the
8223      field decl's class or inherits from it; build the access as
8224      `this$<n>.<field>'. Note that we will break the `private' barrier
8225      if we're not emitting bytecodes. */
8226   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8227       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8228     {
8229       tree thisn = build_current_thisn (current_class);
8230       access = make_qualified_primary (build_wfl_node (thisn),
8231                                        id, EXPR_WFL_LINECOL (id));
8232     }
8233   /* Otherwise, generate access methods to outer this and access the
8234      field (either using an access method or by direct access.) */
8235   else
8236     {
8237       int lc = EXPR_WFL_LINECOL (id);
8238
8239       /* Now we chain the required number of calls to the access$0 to
8240          get a hold to the enclosing instance we need, and then we
8241          build the field access. */
8242       access = build_access_to_thisn (current_class, decl_ctx, lc);
8243
8244       /* If the field is private and we're generating bytecode, then
8245          we generate an access method */
8246       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8247         {
8248           tree name = build_outer_field_access_methods (decl);
8249           access = build_outer_field_access_expr (lc, decl_ctx,
8250                                                   name, access, NULL_TREE);
8251         }
8252       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8253          Once again we break the `private' access rule from a foreign
8254          class. */
8255       else
8256         access = make_qualified_primary (access, id, lc);
8257     }
8258   return resolve_expression_name (access, NULL);
8259 }
8260
8261 /* Return a nonzero value if NODE describes an outer field inner
8262    access.  */
8263
8264 static int
8265 outer_field_access_p (tree type, tree decl)
8266 {
8267   if (!INNER_CLASS_TYPE_P (type)
8268       || TREE_CODE (decl) != FIELD_DECL
8269       || DECL_CONTEXT (decl) == type)
8270     return 0;
8271
8272   /* If the inner class extends the declaration context of the field
8273      we're trying to access, then this isn't an outer field access */
8274   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8275     return 0;
8276
8277   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8278        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8279     {
8280       if (type == DECL_CONTEXT (decl))
8281         return 1;
8282
8283       if (!DECL_CONTEXT (TYPE_NAME (type)))
8284         {
8285           /* Before we give up, see whether the field is inherited from
8286              the enclosing context we're considering. */
8287           if (inherits_from_p (type, DECL_CONTEXT (decl)))
8288             return 1;
8289           break;
8290         }
8291     }
8292
8293   return 0;
8294 }
8295
8296 /* Return a nonzero value if NODE represents an outer field inner
8297    access that was been already expanded. As a side effect, it returns
8298    the name of the field being accessed and the argument passed to the
8299    access function, suitable for a regeneration of the access method
8300    call if necessary. */
8301
8302 static int
8303 outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8304                                tree *arg)
8305 {
8306   int identified = 0;
8307
8308   if (TREE_CODE (node) != CALL_EXPR)
8309     return 0;
8310
8311   /* Well, gcj generates slightly different tree nodes when compiling
8312      to native or bytecodes. It's the case for function calls. */
8313
8314   if (flag_emit_class_files
8315       && TREE_CODE (node) == CALL_EXPR
8316       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8317     identified = 1;
8318   else if (!flag_emit_class_files)
8319     {
8320       node = TREE_OPERAND (node, 0);
8321
8322       if (node && TREE_OPERAND (node, 0)
8323           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8324         {
8325           node = TREE_OPERAND (node, 0);
8326           if (TREE_OPERAND (node, 0)
8327               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8328               && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8329                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8330             identified = 1;
8331         }
8332     }
8333
8334   if (identified && name && arg_type && arg)
8335     {
8336       tree argument = TREE_OPERAND (node, 1);
8337       *name = DECL_NAME (TREE_OPERAND (node, 0));
8338       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8339       *arg = TREE_VALUE (argument);
8340     }
8341   return identified;
8342 }
8343
8344 /* Detect in NODE an outer field read access from an inner class and
8345    transform it into a write with RHS as an argument. This function is
8346    called from the java_complete_lhs when an assignment to a LHS can
8347    be identified. */
8348
8349 static tree
8350 outer_field_access_fix (tree wfl, tree node, tree rhs)
8351 {
8352   tree name, arg_type, arg;
8353
8354   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8355     {
8356       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8357                                             arg_type, name, arg, rhs);
8358       return java_complete_tree (node);
8359     }
8360   return NULL_TREE;
8361 }
8362
8363 /* Construct the expression that calls an access method:
8364      <type>.access$<n>(<arg1> [, <arg2>]);
8365
8366    ARG2 can be NULL and will be omitted in that case. It will denote a
8367    read access.  */
8368
8369 static tree
8370 build_outer_field_access_expr (int lc, tree type, tree access_method_name,
8371                                tree arg1, tree arg2)
8372 {
8373   tree args, cn, access;
8374
8375   args = arg1 ? arg1 :
8376     build_wfl_node (build_current_thisn (current_class));
8377   args = build_tree_list (NULL_TREE, args);
8378
8379   if (arg2)
8380     args = tree_cons (NULL_TREE, arg2, args);
8381
8382   access = build_method_invocation (build_wfl_node (access_method_name), args);
8383   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8384   return make_qualified_primary (cn, access, lc);
8385 }
8386
8387 static tree
8388 build_new_access_id (void)
8389 {
8390   static int access_n_counter = 1;
8391   char buffer [128];
8392
8393   sprintf (buffer, "access$%d", access_n_counter++);
8394   return get_identifier (buffer);
8395 }
8396
8397 /* Create the static access functions for the outer field DECL. We define a
8398    read:
8399      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8400        return inst$.field;
8401      }
8402    and a write access:
8403      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8404                                      TREE_TYPE (<field>) value$) {
8405        return inst$.field = value$;
8406      }
8407    We should have a usage flags on the DECL so we can lazily turn the ones
8408    we're using for code generation. FIXME.
8409 */
8410
8411 static tree
8412 build_outer_field_access_methods (tree decl)
8413 {
8414   tree id, args, stmt, mdecl;
8415
8416   if (FIELD_INNER_ACCESS_P (decl))
8417     return FIELD_INNER_ACCESS (decl);
8418
8419   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8420
8421   /* Create the identifier and a function named after it. */
8422   id = build_new_access_id ();
8423
8424   /* The identifier is marked as bearing the name of a generated write
8425      access function for outer field accessed from inner classes. */
8426   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8427
8428   /* Create the read access */
8429   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8430   TREE_CHAIN (args) = end_params_node;
8431   stmt = make_qualified_primary (build_wfl_node (inst_id),
8432                                  build_wfl_node (DECL_NAME (decl)), 0);
8433   stmt = build_return (0, stmt);
8434   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8435                                            TREE_TYPE (decl), id, args, stmt);
8436   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8437
8438   /* Create the write access method. No write access for final variable */
8439   if (!FIELD_FINAL (decl))
8440     {
8441       args = build_tree_list (inst_id,
8442                               build_pointer_type (DECL_CONTEXT (decl)));
8443       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8444       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8445       stmt = make_qualified_primary (build_wfl_node (inst_id),
8446                                      build_wfl_node (DECL_NAME (decl)), 0);
8447       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8448                                                 build_wfl_node (wpv_id)));
8449       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8450                                                TREE_TYPE (decl), id,
8451                                                args, stmt);
8452     }
8453   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8454
8455   /* Return the access name */
8456   return FIELD_INNER_ACCESS (decl) = id;
8457 }
8458
8459 /* Build an field access method NAME.  */
8460
8461 static tree
8462 build_outer_field_access_method (tree class, tree type, tree name,
8463                                  tree args, tree body)
8464 {
8465   tree saved_current_function_decl, mdecl;
8466
8467   /* Create the method */
8468   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8469   fix_method_argument_names (args, mdecl);
8470   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8471
8472   /* Attach the method body. */
8473   saved_current_function_decl = current_function_decl;
8474   start_artificial_method_body (mdecl);
8475   java_method_add_stmt (mdecl, body);
8476   end_artificial_method_body (mdecl);
8477   current_function_decl = saved_current_function_decl;
8478
8479   return mdecl;
8480 }
8481
8482 \f
8483 /* This section deals with building access function necessary for
8484    certain kinds of method invocation from inner classes.  */
8485
8486 static tree
8487 build_outer_method_access_method (tree decl)
8488 {
8489   tree saved_current_function_decl, mdecl;
8490   tree args = NULL_TREE, call_args = NULL_TREE;
8491   tree carg, id, body, class;
8492   char buffer [80];
8493   int parm_id_count = 0;
8494
8495   /* Test this abort with an access to a private field */
8496   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8497     abort ();
8498
8499   /* Check the cache first */
8500   if (DECL_FUNCTION_INNER_ACCESS (decl))
8501     return DECL_FUNCTION_INNER_ACCESS (decl);
8502
8503   class = DECL_CONTEXT (decl);
8504
8505   /* Obtain an access identifier and mark it */
8506   id = build_new_access_id ();
8507   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8508
8509   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8510   /* Create the arguments, as much as the original */
8511   for (; carg && carg != end_params_node;
8512        carg = TREE_CHAIN (carg))
8513     {
8514       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8515       args = chainon (args, build_tree_list (get_identifier (buffer),
8516                                              TREE_VALUE (carg)));
8517     }
8518   args = chainon (args, end_params_node);
8519
8520   /* Create the method */
8521   mdecl = create_artificial_method (class, ACC_STATIC,
8522                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8523   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8524   /* There is a potential bug here. We should be able to use
8525      fix_method_argument_names, but then arg names get mixed up and
8526      eventually a constructor will have its this$0 altered and the
8527      outer context won't be assignment properly. The testcase is
8528      stub.java FIXME */
8529   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8530
8531   /* Attach the method body. */
8532   saved_current_function_decl = current_function_decl;
8533   start_artificial_method_body (mdecl);
8534
8535   /* The actual method invocation uses the same args. When invoking a
8536      static methods that way, we don't want to skip the first
8537      argument. */
8538   carg = args;
8539   if (!METHOD_STATIC (decl))
8540     carg = TREE_CHAIN (carg);
8541   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8542     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8543                            call_args);
8544
8545   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8546                                   call_args);
8547   if (!METHOD_STATIC (decl))
8548     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8549                                    body, 0);
8550   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8551     body = build_return (0, body);
8552   java_method_add_stmt (mdecl,body);
8553   end_artificial_method_body (mdecl);
8554   current_function_decl = saved_current_function_decl;
8555
8556   /* Back tag the access function so it know what it accesses */
8557   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8558
8559   /* Tag the current method so it knows it has an access generated */
8560   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8561 }
8562
8563 \f
8564 /* This section of the code deals with building expressions to access
8565    the enclosing instance of an inner class. The enclosing instance is
8566    kept in a generated field called this$<n>, with <n> being the
8567    inner class nesting level (starting from 0.)  */
8568
8569 /* Build an access to a given this$<n>, always chaining access call to
8570    others. Access methods to this$<n> are build on the fly if
8571    necessary. This CAN'T be used to solely access this$<n-1> from
8572    this$<n> (which alway yield to special cases and optimization, see
8573    for example build_outer_field_access).  */
8574
8575 static tree
8576 build_access_to_thisn (tree from, tree to, int lc)
8577 {
8578   tree access = NULL_TREE;
8579
8580   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8581     {
8582       if (!access)
8583         {
8584           access = build_current_thisn (from);
8585           access = build_wfl_node (access);
8586         }
8587       else
8588         {
8589           tree access0_wfl, cn;
8590
8591           maybe_build_thisn_access_method (from);
8592           access0_wfl = build_wfl_node (access0_identifier_node);
8593           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8594           EXPR_WFL_LINECOL (access0_wfl) = lc;
8595           access = build_tree_list (NULL_TREE, access);
8596           access = build_method_invocation (access0_wfl, access);
8597           access = make_qualified_primary (cn, access, lc);
8598         }
8599
8600       /* If FROM isn't an inner class, that's fine, we've done enough.
8601          What we're looking for can be accessed from there.  */
8602       from = DECL_CONTEXT (TYPE_NAME (from));
8603       if (!from)
8604         break;
8605       from = TREE_TYPE (from);
8606     }
8607   return access;
8608 }
8609
8610 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8611    is returned if nothing needs to be generated. Otherwise, the method
8612    generated and a method decl is returned.
8613
8614    NOTE: These generated methods should be declared in a class file
8615    attribute so that they can't be referred to directly.  */
8616
8617 static tree
8618 maybe_build_thisn_access_method (tree type)
8619 {
8620   tree mdecl, args, stmt, rtype;
8621   tree saved_current_function_decl;
8622
8623   /* If TYPE is a top-level class, no access method is required.
8624      If there already is such an access method, bail out. */
8625   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8626     return NULL_TREE;
8627
8628   /* We generate the method. The method looks like:
8629      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8630   */
8631   args = build_tree_list (inst_id, build_pointer_type (type));
8632   TREE_CHAIN (args) = end_params_node;
8633   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8634   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8635                                     access0_identifier_node, args);
8636   fix_method_argument_names (args, mdecl);
8637   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8638   stmt = build_current_thisn (type);
8639   stmt = make_qualified_primary (build_wfl_node (inst_id),
8640                                  build_wfl_node (stmt), 0);
8641   stmt = build_return (0, stmt);
8642
8643   saved_current_function_decl = current_function_decl;
8644   start_artificial_method_body (mdecl);
8645   java_method_add_stmt (mdecl, stmt);
8646   end_artificial_method_body (mdecl);
8647   current_function_decl = saved_current_function_decl;
8648
8649   CLASS_ACCESS0_GENERATED_P (type) = 1;
8650
8651   return mdecl;
8652 }
8653
8654 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8655    the first level of innerclassing. this$1 for the next one, etc...
8656    This function can be invoked with TYPE to NULL, available and then
8657    has to count the parser context.  */
8658
8659 static GTY(()) tree saved_thisn;
8660 static GTY(()) tree saved_type;
8661
8662 static tree
8663 build_current_thisn (tree type)
8664 {
8665   static int saved_i = -1;
8666   static int saved_type_i = 0;
8667   tree decl;
8668   char buffer [24];
8669   int i = 0;
8670
8671   if (type)
8672     {
8673       if (type == saved_type)
8674         i = saved_type_i;
8675       else
8676         {
8677           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8678                decl; decl = DECL_CONTEXT (decl), i++)
8679             ;
8680
8681           saved_type = type;
8682           saved_type_i = i;
8683         }
8684     }
8685   else
8686     i = list_length (GET_CPC_LIST ())-2;
8687
8688   if (i == saved_i)
8689     return saved_thisn;
8690
8691   sprintf (buffer, "this$%d", i);
8692   saved_i = i;
8693   saved_thisn = get_identifier (buffer);
8694   return saved_thisn;
8695 }
8696
8697 /* Return the assignment to the hidden enclosing context `this$<n>'
8698    by the second incoming parameter to the innerclass constructor. The
8699    form used is `this.this$<n> = this$<n>;'.  */
8700
8701 static tree
8702 build_thisn_assign (void)
8703 {
8704   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8705     {
8706       tree thisn = build_current_thisn (current_class);
8707       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8708                                          build_wfl_node (thisn), 0);
8709       tree rhs = build_wfl_node (thisn);
8710       EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8711       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8712     }
8713   return NULL_TREE;
8714 }
8715
8716 \f
8717 /* Building the synthetic `class$' used to implement the `.class' 1.1
8718    extension for non primitive types. This method looks like:
8719
8720     static Class class$(String type) throws NoClassDefFoundError
8721     {
8722       try {return (java.lang.Class.forName (String));}
8723       catch (ClassNotFoundException e) {
8724         throw new NoClassDefFoundError(e.getMessage());}
8725     } */
8726
8727 static GTY(()) tree get_message_wfl;
8728 static GTY(()) tree type_parm_wfl;
8729
8730 static tree
8731 build_dot_class_method (tree class)
8732 {
8733 #define BWF(S) build_wfl_node (get_identifier ((S)))
8734 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8735   tree args, tmp, saved_current_function_decl, mdecl, qual_name;
8736   tree stmt, throw_stmt;
8737
8738   if (!get_message_wfl)
8739     {
8740       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8741       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8742     }
8743
8744   /* Build the arguments */
8745   args = build_tree_list (get_identifier ("type$"),
8746                           build_pointer_type (string_type_node));
8747   TREE_CHAIN (args) = end_params_node;
8748
8749   /* Build the qualified name java.lang.Class.forName */
8750   tmp = MQN (MQN (MQN (BWF ("java"),
8751                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8752
8753   /* Create the "class$" function */
8754   mdecl = create_artificial_method (class, ACC_STATIC,
8755                                     build_pointer_type (class_type_node),
8756                                     classdollar_identifier_node, args);
8757   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8758                    BWF ("NoClassDefFoundError"));
8759   DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE, qual_name);
8760   register_incomplete_type (JDEP_EXCEPTION, qual_name, NULL_TREE, NULL_TREE);
8761   JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
8762     &TREE_VALUE (DECL_FUNCTION_THROWS (mdecl));
8763
8764   /* We start by building the try block. We need to build:
8765        return (java.lang.Class.forName (type)); */
8766   stmt = build_method_invocation (tmp,
8767                                   build_tree_list (NULL_TREE, type_parm_wfl));
8768   stmt = build_return (0, stmt);
8769
8770   /* Now onto the catch block. We start by building the expression
8771      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8772   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8773                                     get_message_wfl, 0);
8774   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8775
8776   /* Build new NoClassDefFoundError (_.getMessage) */
8777   throw_stmt = build_new_invocation
8778     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8779      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8780
8781   /* Build the throw, (it's too early to use BUILD_THROW) */
8782   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8783
8784   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8785   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8786                    BWF ("ClassNotFoundException"));
8787   stmt = encapsulate_with_try_catch (0, qual_name, stmt, throw_stmt);
8788
8789   fix_method_argument_names (args, mdecl);
8790   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8791   saved_current_function_decl = current_function_decl;
8792   start_artificial_method_body (mdecl);
8793   java_method_add_stmt (mdecl, stmt);
8794   end_artificial_method_body (mdecl);
8795   current_function_decl = saved_current_function_decl;
8796   TYPE_DOT_CLASS (class) = mdecl;
8797
8798   return mdecl;
8799 }
8800
8801 static tree
8802 build_dot_class_method_invocation (tree this_class, tree type)
8803 {
8804   tree dot_class_method = TYPE_DOT_CLASS (this_class);
8805   tree sig_id, s, t;
8806
8807   if (TYPE_ARRAY_P (type))
8808     sig_id = build_java_signature (type);
8809   else
8810     sig_id = DECL_NAME (TYPE_NAME (type));
8811
8812   /* Ensure that the proper name separator is used */
8813   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8814                                IDENTIFIER_LENGTH (sig_id));
8815
8816   s = build_string (IDENTIFIER_LENGTH (sig_id),
8817                     IDENTIFIER_POINTER (sig_id));
8818   t = build_method_invocation (build_wfl_node (DECL_NAME (dot_class_method)),
8819                                build_tree_list (NULL_TREE, s));
8820   if (DECL_CONTEXT (dot_class_method) != this_class)
8821     {
8822       tree class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (dot_class_method)));
8823       t = make_qualified_primary (build_wfl_node (class_name), t, 0);
8824     }
8825   return t;
8826 }
8827
8828 /* This section of the code deals with constructor.  */
8829
8830 /* Craft a body for default constructor. Patch existing constructor
8831    bodies with call to super() and field initialization statements if
8832    necessary.  */
8833
8834 static void
8835 fix_constructors (tree mdecl)
8836 {
8837   tree iii;                     /* Instance Initializer Invocation */
8838   tree body = DECL_FUNCTION_BODY (mdecl);
8839   tree thisn_assign, compound = NULL_TREE;
8840   tree class_type = DECL_CONTEXT (mdecl);
8841
8842   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8843     return;
8844   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8845
8846   if (!body)
8847     {
8848       /* It is an error for the compiler to generate a default
8849          constructor if the superclass doesn't have a constructor that
8850          takes no argument, or the same args for an anonymous class */
8851       if (verify_constructor_super (mdecl))
8852         {
8853           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8854           tree save = DECL_NAME (mdecl);
8855           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8856           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8857           parse_error_context
8858             (lookup_cl (TYPE_NAME (class_type)),
8859              "No constructor matching `%s' found in class `%s'",
8860              lang_printable_name (mdecl, 0), n);
8861           DECL_NAME (mdecl) = save;
8862         }
8863
8864       /* The constructor body must be crafted by hand. It's the
8865          constructor we defined when we realize we didn't have the
8866          CLASSNAME() constructor */
8867       start_artificial_method_body (mdecl);
8868
8869       /* Insert an assignment to the this$<n> hidden field, if
8870          necessary */
8871       if ((thisn_assign = build_thisn_assign ()))
8872         java_method_add_stmt (mdecl, thisn_assign);
8873
8874       /* We don't generate a super constructor invocation if we're
8875          compiling java.lang.Object. build_super_invocation takes care
8876          of that. */
8877       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8878
8879       /* FIXME */
8880       if ((iii = build_instinit_invocation (class_type)))
8881         java_method_add_stmt (mdecl, iii);
8882
8883       end_artificial_method_body (mdecl);
8884     }
8885   /* Search for an explicit constructor invocation */
8886   else
8887     {
8888       int found = 0;
8889       int invokes_this = 0;
8890       tree found_call = NULL_TREE;
8891       tree main_block = BLOCK_EXPR_BODY (body);
8892
8893       while (body)
8894         switch (TREE_CODE (body))
8895           {
8896           case CALL_EXPR:
8897             found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8898             if (CALL_THIS_CONSTRUCTOR_P (body))
8899               invokes_this = 1;
8900             body = NULL_TREE;
8901             break;
8902           case COMPOUND_EXPR:
8903           case EXPR_WITH_FILE_LOCATION:
8904             found_call = body;
8905             body = TREE_OPERAND (body, 0);
8906             break;
8907           case BLOCK:
8908             found_call = body;
8909             body = BLOCK_EXPR_BODY (body);
8910             break;
8911           default:
8912             found = 0;
8913             body = NULL_TREE;
8914           }
8915
8916       /* Generate the assignment to this$<n>, if necessary */
8917       if ((thisn_assign = build_thisn_assign ()))
8918         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8919
8920       /* The constructor is missing an invocation of super() */
8921       if (!found)
8922         compound = add_stmt_to_compound (compound, NULL_TREE,
8923                                          build_super_invocation (mdecl));
8924       /* Explicit super() invocation should take place before the
8925          instance initializer blocks. */
8926       else
8927         {
8928           compound = add_stmt_to_compound (compound, NULL_TREE,
8929                                            TREE_OPERAND (found_call, 0));
8930           TREE_OPERAND (found_call, 0) = empty_stmt_node;
8931         }
8932
8933       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
8934
8935       /* Insert the instance initializer block right after. */
8936       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
8937         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
8938
8939       /* Fix the constructor main block if we're adding extra stmts */
8940       if (compound)
8941         {
8942           compound = add_stmt_to_compound (compound, NULL_TREE,
8943                                            BLOCK_EXPR_BODY (main_block));
8944           BLOCK_EXPR_BODY (main_block) = compound;
8945         }
8946     }
8947 }
8948
8949 /* Browse constructors in the super class, searching for a constructor
8950    that doesn't take any argument. Return 0 if one is found, 1
8951    otherwise.  If the current class is an anonymous inner class, look
8952    for something that has the same signature. */
8953
8954 static int
8955 verify_constructor_super (tree mdecl)
8956 {
8957   tree class = CLASSTYPE_SUPER (current_class);
8958   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8959   tree sdecl;
8960
8961   if (!class)
8962     return 0;
8963
8964   if (ANONYMOUS_CLASS_P (current_class))
8965     {
8966       tree mdecl_arg_type;
8967       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8968       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8969         if (DECL_CONSTRUCTOR_P (sdecl))
8970           {
8971             tree m_arg_type;
8972             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8973             if (super_inner)
8974               arg_type = TREE_CHAIN (arg_type);
8975             for (m_arg_type = mdecl_arg_type;
8976                  (arg_type != end_params_node
8977                   && m_arg_type != end_params_node);
8978                  arg_type = TREE_CHAIN (arg_type),
8979                    m_arg_type = TREE_CHAIN (m_arg_type))
8980               if (!valid_method_invocation_conversion_p
8981                      (TREE_VALUE (arg_type),
8982                       TREE_VALUE (m_arg_type)))
8983                 break;
8984
8985             if (arg_type == end_params_node && m_arg_type == end_params_node)
8986               return 0;
8987           }
8988     }
8989   else
8990     {
8991       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8992         {
8993           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8994           if (super_inner)
8995             arg = TREE_CHAIN (arg);
8996           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
8997             return 0;
8998         }
8999     }
9000   return 1;
9001 }
9002
9003 /* Generate code for all context remembered for code generation.  */
9004
9005 static GTY(()) tree reversed_class_list;
9006 void
9007 java_expand_classes (void)
9008 {
9009   int save_error_count = 0;
9010   static struct parser_ctxt *cur_ctxp = NULL;
9011
9012   java_parse_abort_on_error ();
9013   if (!(ctxp = ctxp_for_generation))
9014     return;
9015   java_layout_classes ();
9016   java_parse_abort_on_error ();
9017
9018   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9019     {
9020       tree current;
9021       for (current = cur_ctxp->class_list;
9022            current;
9023            current = TREE_CHAIN (current))
9024         gen_indirect_dispatch_tables (TREE_TYPE (current));
9025     }
9026
9027   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9028     {
9029       ctxp = cur_ctxp;
9030       input_filename = ctxp->filename;
9031       lang_init_source (2);            /* Error msgs have method prototypes */
9032       java_complete_expand_classes (); /* Complete and expand classes */
9033       java_parse_abort_on_error ();
9034     }
9035   input_filename = main_input_filename;
9036
9037   /* Find anonymous classes and expand their constructor. This extra pass is
9038      necessary because the constructor itself is only generated when the
9039      method in which it is defined is expanded. */
9040   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9041     {
9042       tree current;
9043       ctxp = cur_ctxp;
9044       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9045         {
9046           output_class = current_class = TREE_TYPE (current);
9047           if (ANONYMOUS_CLASS_P (current_class))
9048             {
9049               tree d;
9050               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9051                 {
9052                   if (DECL_CONSTRUCTOR_P (d))
9053                     {
9054                       restore_line_number_status (1);
9055                       java_complete_expand_method (d);
9056                       restore_line_number_status (0);
9057                       break;    /* There is only one constructor. */
9058                     }
9059                 }
9060             }
9061         }
9062     }
9063
9064   /* Expanding the constructors of anonymous classes generates access
9065      methods.  Scan all the methods looking for null DECL_RESULTs --
9066      this will be the case if a method hasn't been expanded.  */
9067   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9068     {
9069       tree current;
9070       ctxp = cur_ctxp;
9071       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9072         {
9073           tree d;
9074           output_class = current_class = TREE_TYPE (current);
9075           for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9076             {
9077               if (DECL_RESULT (d) == NULL_TREE)
9078                 {
9079                   restore_line_number_status (1);
9080                   java_complete_expand_method (d);
9081                   restore_line_number_status (0);
9082                 }
9083             }
9084         }
9085     }
9086
9087   /* ???  Instead of all this we could iterate around the list of
9088      classes until there were no more un-expanded methods.  It would
9089      take a little longer -- one pass over the whole list of methods
9090      -- but it would be simpler.  Like this:  */
9091 #if 0
9092     {
9093       int something_changed;
9094
9095       do
9096         {
9097           something_changed = 0;
9098           for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9099             {
9100               tree current;
9101               ctxp = cur_ctxp;
9102               for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9103                 {
9104                   tree d;
9105                   output_class = current_class = TREE_TYPE (current);
9106                   for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9107                     {
9108                       if (DECL_RESULT (d) == NULL_TREE)
9109                         {
9110                           something_changed = 1;
9111                           restore_line_number_status (1);
9112                           java_complete_expand_method (d);
9113                           restore_line_number_status (0);
9114                         }
9115                     }
9116                 }
9117             }
9118         }
9119       while (something_changed);
9120     }
9121 #endif
9122
9123   /* If we've found error at that stage, don't try to generate
9124      anything, unless we're emitting xrefs or checking the syntax only
9125      (but not using -fsyntax-only for the purpose of generating
9126      bytecode. */
9127   if (java_error_count && !flag_emit_xref
9128       && (!flag_syntax_only && !flag_emit_class_files))
9129     return;
9130
9131   /* Now things are stable, go for generation of the class data. */
9132
9133   /* We pessimistically marked all methods and fields external until
9134      we knew what set of classes we were planning to compile.  Now mark
9135      those that will be generated locally as not external.  */
9136   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9137     {
9138       tree current;
9139       ctxp = cur_ctxp;
9140       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9141         java_mark_class_local (TREE_TYPE (current));
9142     }
9143
9144   /* Compile the classes.  */
9145   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9146     {
9147       tree current;
9148       reversed_class_list = NULL;
9149
9150       ctxp = cur_ctxp;
9151
9152       /* We write out the classes in reverse order.  This ensures that
9153          inner classes are written before their containing classes,
9154          which is important for parallel builds.  Otherwise, the
9155          class file for the outer class may be found, but the class
9156          file for the inner class may not be present.  In that
9157          situation, the compiler cannot fall back to the original
9158          source, having already read the outer class, so we must
9159          prevent that situation.  */
9160       for (current = ctxp->class_list;
9161            current;
9162            current = TREE_CHAIN (current))
9163         reversed_class_list
9164           = tree_cons (NULL_TREE, current, reversed_class_list);
9165
9166       for (current = reversed_class_list;
9167            current;
9168            current = TREE_CHAIN (current))
9169         {
9170           output_class = current_class = TREE_TYPE (TREE_VALUE (current));
9171           if (flag_emit_class_files)
9172             write_classfile (current_class);
9173           if (flag_emit_xref)
9174             expand_xref (current_class);
9175           else if (! flag_syntax_only)
9176             java_expand_method_bodies (current_class);
9177         }
9178     }
9179 }
9180
9181 void
9182 java_finish_classes (void)
9183 {
9184   static struct parser_ctxt *cur_ctxp = NULL;
9185   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9186     {
9187       tree current;
9188       ctxp = cur_ctxp;
9189       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9190         {
9191           output_class = current_class = TREE_TYPE (current);
9192           finish_class ();
9193         }
9194     }
9195 }
9196
9197 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9198    a tree list node containing RIGHT. Fore coming RIGHTs will be
9199    chained to this hook. LOCATION contains the location of the
9200    separating `.' operator.  */
9201
9202 static tree
9203 make_qualified_primary (tree primary, tree right, int location)
9204 {
9205   tree wfl;
9206
9207   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9208     wfl = build_wfl_wrap (primary, location);
9209   else
9210     {
9211       wfl = primary;
9212       /* If wfl wasn't qualified, we build a first anchor */
9213       if (!EXPR_WFL_QUALIFICATION (wfl))
9214         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9215     }
9216
9217   /* And chain them */
9218   EXPR_WFL_LINECOL (right) = location;
9219   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9220   PRIMARY_P (wfl) =  1;
9221   return wfl;
9222 }
9223
9224 /* Simple merge of two name separated by a `.' */
9225
9226 static tree
9227 merge_qualified_name (tree left, tree right)
9228 {
9229   tree node;
9230   if (!left && !right)
9231     return NULL_TREE;
9232
9233   if (!left)
9234     return right;
9235
9236   if (!right)
9237     return left;
9238
9239   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9240                 IDENTIFIER_LENGTH (left));
9241   obstack_1grow (&temporary_obstack, '.');
9242   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9243                  IDENTIFIER_LENGTH (right));
9244   node =  get_identifier (obstack_base (&temporary_obstack));
9245   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9246   QUALIFIED_P (node) = 1;
9247   return node;
9248 }
9249
9250 /* Merge the two parts of a qualified name into LEFT.  Set the
9251    location information of the resulting node to LOCATION, usually
9252    inherited from the location information of the `.' operator. */
9253
9254 static tree
9255 make_qualified_name (tree left, tree right, int location)
9256 {
9257 #ifdef USE_COMPONENT_REF
9258   tree node = build (COMPONENT_REF, NULL_TREE, left, right);
9259   EXPR_WFL_LINECOL (node) = location;
9260   return node;
9261 #else
9262   tree left_id = EXPR_WFL_NODE (left);
9263   tree right_id = EXPR_WFL_NODE (right);
9264   tree wfl, merge;
9265
9266   merge = merge_qualified_name (left_id, right_id);
9267
9268   /* Left wasn't qualified and is now qualified */
9269   if (!QUALIFIED_P (left_id))
9270     {
9271       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9272       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9273       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9274     }
9275
9276   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9277   EXPR_WFL_LINECOL (wfl) = location;
9278   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9279
9280   EXPR_WFL_NODE (left) = merge;
9281   return left;
9282 #endif
9283 }
9284
9285 /* Extract the last identifier component of the qualified in WFL. The
9286    last identifier is removed from the linked list */
9287
9288 static tree
9289 cut_identifier_in_qualified (tree wfl)
9290 {
9291   tree q;
9292   tree previous = NULL_TREE;
9293   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9294     if (!TREE_CHAIN (q))
9295       {
9296         if (!previous)
9297           /* Operating on a non qualified qualified WFL.  */
9298           abort ();
9299
9300         TREE_CHAIN (previous) = NULL_TREE;
9301         return TREE_PURPOSE (q);
9302       }
9303 }
9304
9305 /* Resolve the expression name NAME. Return its decl.  */
9306
9307 static tree
9308 resolve_expression_name (tree id, tree *orig)
9309 {
9310   tree name = EXPR_WFL_NODE (id);
9311   tree decl;
9312
9313   /* 6.5.5.1: Simple expression names */
9314   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9315     {
9316       /* 15.13.1: NAME can appear within the scope of a local variable
9317          declaration */
9318       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9319         return decl;
9320
9321       /* 15.13.1: NAME can appear within a class declaration */
9322       else
9323         {
9324           decl = lookup_field_wrapper (current_class, name);
9325           if (decl)
9326             {
9327               tree access = NULL_TREE;
9328               int fs = FIELD_STATIC (decl);
9329
9330               /* If we're accessing an outer scope local alias, make
9331                  sure we change the name of the field we're going to
9332                  build access to. */
9333               if (FIELD_LOCAL_ALIAS_USED (decl))
9334                 name = DECL_NAME (decl);
9335
9336               check_deprecation (id, decl);
9337
9338               /* Instance variable (8.3.1.1) can't appear within
9339                  static method, static initializer or initializer for
9340                  a static variable. */
9341               if (!fs && METHOD_STATIC (current_function_decl))
9342                 {
9343                   static_ref_err (id, name, current_class);
9344                   return error_mark_node;
9345                 }
9346               /* Instance variables can't appear as an argument of
9347                  an explicit constructor invocation */
9348               if (!fs && ctxp->explicit_constructor_p
9349                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9350                 {
9351                   parse_error_context
9352                     (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9353                   return error_mark_node;
9354                 }
9355
9356               /* If we're processing an inner class and we're trying
9357                  to access a field belonging to an outer class, build
9358                  the access to the field */
9359               if (!fs && outer_field_access_p (current_class, decl))
9360                 {
9361                   if (CLASS_STATIC (TYPE_NAME (current_class)))
9362                     {
9363                       static_ref_err (id, DECL_NAME (decl), current_class);
9364                       return error_mark_node;
9365                     }
9366                   access = build_outer_field_access (id, decl);
9367                   if (orig)
9368                     *orig = access;
9369                   return access;
9370                 }
9371
9372               /* Otherwise build what it takes to access the field */
9373               access = build_field_ref ((fs ? NULL_TREE : current_this),
9374                                         DECL_CONTEXT (decl), name);
9375               if (fs)
9376                 access = maybe_build_class_init_for_field (decl, access);
9377               /* We may be asked to save the real field access node */
9378               if (orig)
9379                 *orig = access;
9380               /* Last check: can we access the field? */
9381               if (not_accessible_p (current_class, decl, NULL_TREE, 0))
9382                 {
9383                   not_accessible_field_error (id, decl);
9384                   return error_mark_node;
9385                 }
9386               /* And we return what we got */
9387               return access;
9388             }
9389           /* Fall down to error report on undefined variable */
9390         }
9391     }
9392   /* 6.5.5.2 Qualified Expression Names */
9393   else
9394     {
9395       if (orig)
9396         *orig = NULL_TREE;
9397       qualify_ambiguous_name (id);
9398       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9399       /* 15.10.2: Accessing Superclass Members using super */
9400       return resolve_field_access (id, orig, NULL);
9401     }
9402
9403   /* We've got an error here */
9404   if (INNER_CLASS_TYPE_P (current_class))
9405     parse_error_context (id,
9406                          "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9407                          IDENTIFIER_POINTER (name),
9408                          IDENTIFIER_POINTER (DECL_NAME
9409                                              (TYPE_NAME (current_class))));
9410   else
9411     parse_error_context (id, "Undefined variable `%s'",
9412                          IDENTIFIER_POINTER (name));
9413
9414   return error_mark_node;
9415 }
9416
9417 static void
9418 static_ref_err (tree wfl, tree field_id, tree class_type)
9419 {
9420   parse_error_context
9421     (wfl,
9422      "Can't make a static reference to nonstatic variable `%s' in class `%s'",
9423      IDENTIFIER_POINTER (field_id),
9424      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9425 }
9426
9427 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9428    We return something suitable to generate the field access. We also
9429    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9430    recipient's address can be null. */
9431
9432 static tree
9433 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9434 {
9435   int is_static = 0;
9436   tree field_ref;
9437   tree decl, where_found, type_found;
9438
9439   if (resolve_qualified_expression_name (qual_wfl, &decl,
9440                                          &where_found, &type_found))
9441     return error_mark_node;
9442
9443   /* Resolve the LENGTH field of an array here */
9444   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9445       && type_found && TYPE_ARRAY_P (type_found)
9446       && ! flag_emit_class_files && ! flag_emit_xref)
9447     {
9448       tree length = build_java_array_length_access (where_found);
9449       field_ref = length;
9450
9451       /* In case we're dealing with a static array, we need to
9452          initialize its class before the array length can be fetched.
9453          It's also a good time to create a DECL_RTL for the field if
9454          none already exists, otherwise if the field was declared in a
9455          class found in an external file and hasn't been (and won't
9456          be) accessed for its value, none will be created. */
9457       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9458         {
9459           build_static_field_ref (where_found);
9460           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9461         }
9462     }
9463   /* We might have been trying to resolve field.method(). In which
9464      case, the resolution is over and decl is the answer */
9465   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9466     field_ref = decl;
9467   else if (JDECL_P (decl))
9468     {
9469       if (!type_found)
9470         type_found = DECL_CONTEXT (decl);
9471       is_static = FIELD_STATIC (decl);
9472       field_ref = build_field_ref ((is_static && !flag_emit_xref?
9473                                     NULL_TREE : where_found),
9474                                    type_found, DECL_NAME (decl));
9475       if (field_ref == error_mark_node)
9476         return error_mark_node;
9477       if (is_static)
9478         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9479
9480       /* If we're looking at a static field, we may need to generate a
9481          class initialization for it.  This can happen when the access
9482          looks like `field.ref', where `field' is a static field in an
9483          interface we implement.  */
9484       if (!flag_emit_class_files
9485           && !flag_emit_xref
9486           && TREE_CODE (where_found) == VAR_DECL
9487           && FIELD_STATIC (where_found))
9488         {
9489           build_static_field_ref (where_found);
9490           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9491         }
9492     }
9493   else
9494     field_ref = decl;
9495
9496   if (field_decl)
9497     *field_decl = decl;
9498   if (field_type)
9499     *field_type = (QUAL_DECL_TYPE (decl) ?
9500                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9501   return field_ref;
9502 }
9503
9504 /* If NODE is an access to f static field, strip out the class
9505    initialization part and return the field decl, otherwise, return
9506    NODE. */
9507
9508 static tree
9509 strip_out_static_field_access_decl (tree node)
9510 {
9511   if (TREE_CODE (node) == COMPOUND_EXPR)
9512     {
9513       tree op1 = TREE_OPERAND (node, 1);
9514       if (TREE_CODE (op1) == COMPOUND_EXPR)
9515          {
9516            tree call = TREE_OPERAND (op1, 0);
9517            if (TREE_CODE (call) == CALL_EXPR
9518                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9519                && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9520                == soft_initclass_node)
9521              return TREE_OPERAND (op1, 1);
9522          }
9523       else if (JDECL_P (op1))
9524         return op1;
9525     }
9526   return node;
9527 }
9528
9529 /* 6.5.5.2: Qualified Expression Names */
9530
9531 static int
9532 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9533                                    tree *where_found, tree *type_found)
9534 {
9535   int from_type = 0;            /* Field search initiated from a type */
9536   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9537   int previous_call_static = 0;
9538   int is_static;
9539   tree decl = NULL_TREE, type = NULL_TREE, q;
9540   /* For certain for of inner class instantiation */
9541   tree saved_current, saved_this;
9542 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9543   { current_class = saved_current; current_this = saved_this;}
9544
9545   *type_found = *where_found = NULL_TREE;
9546
9547   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9548     {
9549       tree qual_wfl = QUAL_WFL (q);
9550       tree ret_decl;            /* for EH checking */
9551       int location;             /* for EH checking */
9552
9553       /* 15.10.1 Field Access Using a Primary */
9554       switch (TREE_CODE (qual_wfl))
9555         {
9556         case CALL_EXPR:
9557         case NEW_CLASS_EXPR:
9558           /* If the access to the function call is a non static field,
9559              build the code to access it. */
9560           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9561             {
9562               decl = maybe_access_field (decl, *where_found,
9563                                          DECL_CONTEXT (decl));
9564               if (decl == error_mark_node)
9565                 return 1;
9566             }
9567
9568           /* And code for the function call */
9569           if (complete_function_arguments (qual_wfl))
9570             return 1;
9571
9572           /* We might have to setup a new current class and a new this
9573              for the search of an inner class, relative to the type of
9574              a expression resolved as `decl'. The current values are
9575              saved and restored shortly after */
9576           saved_current = current_class;
9577           saved_this = current_this;
9578           if (decl
9579               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9580                   || from_qualified_this))
9581             {
9582               /* If we still have `from_qualified_this', we have the form
9583                  <T>.this.f() and we need to build <T>.this */
9584               if (from_qualified_this)
9585                 {
9586                   decl = build_access_to_thisn (current_class, type, 0);
9587                   decl = java_complete_tree (decl);
9588                   type = TREE_TYPE (TREE_TYPE (decl));
9589                 }
9590               current_class = type;
9591               current_this = decl;
9592               from_qualified_this = 0;
9593             }
9594
9595           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9596             CALL_USING_SUPER (qual_wfl) = 1;
9597           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9598                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9599           *where_found = patch_method_invocation (qual_wfl, decl, type,
9600                                                   from_super,
9601                                                   &is_static, &ret_decl);
9602           from_super = 0;
9603           if (*where_found == error_mark_node)
9604             {
9605               RESTORE_THIS_AND_CURRENT_CLASS;
9606               return 1;
9607             }
9608           *type_found = type = QUAL_DECL_TYPE (*where_found);
9609
9610           *where_found = force_evaluation_order (*where_found);
9611
9612           /* If we're creating an inner class instance, check for that
9613              an enclosing instance is in scope */
9614           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9615               && INNER_ENCLOSING_SCOPE_CHECK (type))
9616             {
9617               parse_error_context
9618                 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
9619                  lang_printable_name (type, 0),
9620                  (!current_this ? "" :
9621                   "; an explicit one must be provided when creating this inner class"));
9622               RESTORE_THIS_AND_CURRENT_CLASS;
9623               return 1;
9624             }
9625
9626           /* In case we had to change then to resolve a inner class
9627              instantiation using a primary qualified by a `new' */
9628           RESTORE_THIS_AND_CURRENT_CLASS;
9629
9630           if (location)
9631             {
9632               tree arguments = NULL_TREE;
9633               if (TREE_CODE (qual_wfl) == CALL_EXPR
9634                   && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9635                 arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9636               check_thrown_exceptions (location, ret_decl, arguments);
9637             }
9638
9639           /* If the previous call was static and this one is too,
9640              build a compound expression to hold the two (because in
9641              that case, previous function calls aren't transported as
9642              forcoming function's argument. */
9643           if (previous_call_static && is_static)
9644             {
9645               decl = build (COMPOUND_EXPR, TREE_TYPE (*where_found),
9646                             decl, *where_found);
9647               TREE_SIDE_EFFECTS (decl) = 1;
9648             }
9649           else
9650             {
9651               previous_call_static = is_static;
9652               decl = *where_found;
9653             }
9654           from_type = 0;
9655           continue;
9656
9657         case NEW_ARRAY_EXPR:
9658         case NEW_ANONYMOUS_ARRAY_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 CONVERT_EXPR:
9666           *where_found = decl = java_complete_tree (qual_wfl);
9667           if (decl == error_mark_node)
9668             return 1;
9669           *type_found = type = QUAL_DECL_TYPE (decl);
9670           from_cast = 1;
9671           continue;
9672
9673         case CONDITIONAL_EXPR:
9674         case STRING_CST:
9675         case MODIFY_EXPR:
9676           *where_found = decl = java_complete_tree (qual_wfl);
9677           if (decl == error_mark_node)
9678             return 1;
9679           *type_found = type = QUAL_DECL_TYPE (decl);
9680           continue;
9681
9682         case ARRAY_REF:
9683           /* If the access to the function call is a non static field,
9684              build the code to access it. */
9685           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9686             {
9687               decl = maybe_access_field (decl, *where_found, type);
9688               if (decl == error_mark_node)
9689                 return 1;
9690             }
9691           /* And code for the array reference expression */
9692           decl = java_complete_tree (qual_wfl);
9693           if (decl == error_mark_node)
9694             return 1;
9695           type = QUAL_DECL_TYPE (decl);
9696           continue;
9697
9698         case PLUS_EXPR:
9699           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9700             return 1;
9701           if ((type = patch_string (decl)))
9702             decl = type;
9703           *where_found = QUAL_RESOLUTION (q) = decl;
9704           *type_found = type = TREE_TYPE (decl);
9705           break;
9706
9707         case CLASS_LITERAL:
9708           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9709             return 1;
9710           *where_found = QUAL_RESOLUTION (q) = decl;
9711           *type_found = type = TREE_TYPE (decl);
9712           break;
9713
9714         default:
9715           /* Fix for -Wall Just go to the next statement. Don't
9716              continue */
9717           break;
9718         }
9719
9720       /* If we fall here, we weren't processing a (static) function call. */
9721       previous_call_static = 0;
9722
9723       /* It can be the keyword THIS */
9724       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9725           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9726         {
9727           if (!current_this)
9728             {
9729               parse_error_context
9730                 (wfl, "Keyword `this' used outside allowed context");
9731               return 1;
9732             }
9733           if (ctxp->explicit_constructor_p
9734               && type == current_class)
9735             {
9736               parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9737               return 1;
9738             }
9739           /* We have to generate code for intermediate access */
9740           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9741             {
9742               *where_found = decl = current_this;
9743               *type_found = type = QUAL_DECL_TYPE (decl);
9744             }
9745           /* We're trying to access the this from somewhere else. Make sure
9746              it's allowed before doing so. */
9747           else
9748             {
9749               if (!enclosing_context_p (type, current_class))
9750                 {
9751                   char *p  = xstrdup (lang_printable_name (type, 0));
9752                   parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9753                                        p, p,
9754                                        lang_printable_name (current_class, 0));
9755                   free (p);
9756                   return 1;
9757                 }
9758               from_qualified_this = 1;
9759               /* If there's nothing else after that, we need to
9760                  produce something now, otherwise, the section of the
9761                  code that needs to produce <T>.this will generate
9762                  what is necessary. */
9763               if (!TREE_CHAIN (q))
9764                 {
9765                   decl = build_access_to_thisn (current_class, type, 0);
9766                   *where_found = decl = java_complete_tree (decl);
9767                   *type_found = type = TREE_TYPE (decl);
9768                 }
9769             }
9770
9771           from_type = 0;
9772           continue;
9773         }
9774
9775       /* 15.10.2 Accessing Superclass Members using SUPER */
9776       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9777           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9778         {
9779           tree node;
9780           /* Check on the restricted use of SUPER */
9781           if (METHOD_STATIC (current_function_decl)
9782               || current_class == object_type_node)
9783             {
9784               parse_error_context
9785                 (wfl, "Keyword `super' used outside allowed context");
9786               return 1;
9787             }
9788           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9789           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9790                              CLASSTYPE_SUPER (current_class),
9791                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9792           *where_found = decl = java_complete_tree (node);
9793           if (decl == error_mark_node)
9794             return 1;
9795           *type_found = type = QUAL_DECL_TYPE (decl);
9796           from_super = from_type = 1;
9797           continue;
9798         }
9799
9800       /* 15.13.1: Can't search for field name in packages, so we
9801          assume a variable/class name was meant. */
9802       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9803         {
9804           tree name;
9805           if ((decl = resolve_package (wfl, &q, &name)))
9806             {
9807               tree list;
9808               *where_found = decl;
9809
9810               /* We want to be absolutely sure that the class is laid
9811                  out. We're going to search something inside it. */
9812               *type_found = type = TREE_TYPE (decl);
9813               layout_class (type);
9814               from_type = 1;
9815
9816               /* Fix them all the way down, if any are left. */
9817               if (q)
9818                 {
9819                   list = TREE_CHAIN (q);
9820                   while (list)
9821                     {
9822                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9823                       list = TREE_CHAIN (list);
9824                     }
9825                 }
9826             }
9827           else
9828             {
9829               if (from_super || from_cast)
9830                 parse_error_context
9831                   ((from_cast ? qual_wfl : wfl),
9832                    "No variable `%s' defined in class `%s'",
9833                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9834                    lang_printable_name (type, 0));
9835               else
9836                 parse_error_context
9837                   (qual_wfl, "Undefined variable or class name: `%s'",
9838                    IDENTIFIER_POINTER (name));
9839               return 1;
9840             }
9841         }
9842
9843       /* We have a type name. It's been already resolved when the
9844          expression was qualified. */
9845       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9846         {
9847           decl = QUAL_RESOLUTION (q);
9848
9849           /* Sneak preview. If next we see a `new', we're facing a
9850              qualification with resulted in a type being selected
9851              instead of a field.  Report the error */
9852           if(TREE_CHAIN (q)
9853              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9854             {
9855               parse_error_context (qual_wfl, "Undefined variable `%s'",
9856                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9857               return 1;
9858             }
9859
9860           if (not_accessible_p (TREE_TYPE (decl), decl, type, 0))
9861             return not_accessible_field_error (qual_wfl, decl);
9862           check_deprecation (qual_wfl, decl);
9863
9864           type = TREE_TYPE (decl);
9865           from_type = 1;
9866         }
9867       /* We resolve an expression name */
9868       else
9869         {
9870           tree field_decl = NULL_TREE;
9871
9872           /* If there exists an early resolution, use it. That occurs
9873              only once and we know that there are more things to
9874              come. Don't do that when processing something after SUPER
9875              (we need more thing to be put in place below */
9876           if (!from_super && QUAL_RESOLUTION (q))
9877             {
9878               decl = QUAL_RESOLUTION (q);
9879               if (!type)
9880                 {
9881                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9882                     {
9883                       if (current_this)
9884                         *where_found = current_this;
9885                       else
9886                         {
9887                           static_ref_err (qual_wfl, DECL_NAME (decl),
9888                                           current_class);
9889                           return 1;
9890                         }
9891                       if (outer_field_access_p (current_class, decl))
9892                         decl = build_outer_field_access (qual_wfl, decl);
9893                     }
9894                   else
9895                     {
9896                       *where_found = TREE_TYPE (decl);
9897                       if (TREE_CODE (*where_found) == POINTER_TYPE)
9898                         *where_found = TREE_TYPE (*where_found);
9899                     }
9900                 }
9901             }
9902
9903           /* Report and error if we're using a numerical literal as a
9904              qualifier. It can only be an INTEGER_CST. */
9905           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9906             {
9907               parse_error_context
9908                 (wfl, "Can't use type `%s' as a qualifier",
9909                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
9910               return 1;
9911             }
9912
9913           /* We have to search for a field, knowing the type of its
9914              container. The flag FROM_TYPE indicates that we resolved
9915              the last member of the expression as a type name, which
9916              means that for the resolution of this field, we'll look
9917              for other errors than if it was resolved as a member of
9918              an other field. */
9919           else
9920             {
9921               int is_static;
9922               tree field_decl_type; /* For layout */
9923
9924               if (!from_type && !JREFERENCE_TYPE_P (type))
9925                 {
9926                   parse_error_context
9927                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9928                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9929                      lang_printable_name (type, 0),
9930                      IDENTIFIER_POINTER (DECL_NAME (decl)));
9931                   return 1;
9932                 }
9933
9934               field_decl = lookup_field_wrapper (type,
9935                                                  EXPR_WFL_NODE (qual_wfl));
9936
9937               /* Maybe what we're trying to access to is an inner
9938                  class, only if decl is a TYPE_DECL. */
9939               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9940                 {
9941                   tree ptr, inner_decl;
9942
9943                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9944                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9945                   if (inner_decl)
9946                     {
9947                       check_inner_class_access (inner_decl, decl, qual_wfl);
9948                       type = TREE_TYPE (inner_decl);
9949                       decl = inner_decl;
9950                       from_type = 1;
9951                       continue;
9952                     }
9953                 }
9954
9955               if (field_decl == NULL_TREE)
9956                 {
9957                   parse_error_context
9958                     (qual_wfl, "No variable `%s' defined in type `%s'",
9959                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9960                      GET_TYPE_NAME (type));
9961                   return 1;
9962                 }
9963               if (field_decl == error_mark_node)
9964                 return 1;
9965
9966               /* Layout the type of field_decl, since we may need
9967                  it. Don't do primitive types or loaded classes. The
9968                  situation of non primitive arrays may not handled
9969                  properly here. FIXME */
9970               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9971                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9972               else
9973                 field_decl_type = TREE_TYPE (field_decl);
9974               if (!JPRIMITIVE_TYPE_P (field_decl_type)
9975                   && !CLASS_LOADED_P (field_decl_type)
9976                   && !TYPE_ARRAY_P (field_decl_type))
9977                 resolve_and_layout (field_decl_type, NULL_TREE);
9978
9979               /* Check on accessibility here */
9980               if (not_accessible_p (current_class, field_decl,
9981                                     DECL_CONTEXT (field_decl), from_super))
9982                 return not_accessible_field_error (qual_wfl,field_decl);
9983               check_deprecation (qual_wfl, field_decl);
9984
9985               /* There are things to check when fields are accessed
9986                  from type. There are no restrictions on a static
9987                  declaration of the field when it is accessed from an
9988                  interface */
9989               is_static = FIELD_STATIC (field_decl);
9990               if (!from_super && from_type
9991                   && !TYPE_INTERFACE_P (type)
9992                   && !is_static
9993                   && (current_function_decl
9994                       && METHOD_STATIC (current_function_decl)))
9995                 {
9996                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
9997                   return 1;
9998                 }
9999               from_cast = from_super = 0;
10000
10001               /* It's an access from a type but it isn't static, we
10002                  make it relative to `this'. */
10003               if (!is_static && from_type)
10004                 decl = current_this;
10005
10006               /* If we need to generate something to get a proper
10007                  handle on what this field is accessed from, do it
10008                  now. */
10009               if (!is_static)
10010                 {
10011                   decl = maybe_access_field (decl, *where_found, *type_found);
10012                   if (decl == error_mark_node)
10013                     return 1;
10014                 }
10015
10016               /* We want to keep the location were found it, and the type
10017                  we found. */
10018               *where_found = decl;
10019               *type_found = type;
10020
10021               /* Generate the correct expression for field access from
10022                  qualified this */
10023               if (from_qualified_this)
10024                 {
10025                   field_decl = build_outer_field_access (qual_wfl, field_decl);
10026                   from_qualified_this = 0;
10027                 }
10028
10029               /* This is the decl found and eventually the next one to
10030                  search from */
10031               decl = field_decl;
10032             }
10033           from_type = 0;
10034           type = QUAL_DECL_TYPE (decl);
10035
10036           /* Sneak preview. If decl is qualified by a `new', report
10037              the error here to be accurate on the peculiar construct */
10038           if (TREE_CHAIN (q)
10039               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10040               && !JREFERENCE_TYPE_P (type))
10041             {
10042               parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
10043                                    lang_printable_name (type, 0));
10044               return 1;
10045             }
10046         }
10047       /* `q' might have changed due to a after package resolution
10048          re-qualification */
10049       if (!q)
10050         break;
10051     }
10052   *found_decl = decl;
10053   return 0;
10054 }
10055
10056 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10057    can't be accessed from REFERENCE (a record type). If MEMBER
10058    features a protected access, we then use WHERE which, if non null,
10059    holds the type of MEMBER's access that is checked against
10060    6.6.2.1. This function should be used when decl is a field or a
10061    method.  */
10062
10063 static int
10064 not_accessible_p (tree reference, tree member, tree where, int from_super)
10065 {
10066   int access_flag = get_access_flags_from_decl (member);
10067
10068   /* Inner classes are processed by check_inner_class_access */
10069   if (INNER_CLASS_TYPE_P (reference))
10070     return 0;
10071
10072   /* Access always granted for members declared public */
10073   if (access_flag & ACC_PUBLIC)
10074     return 0;
10075
10076   /* Check access on protected members */
10077   if (access_flag & ACC_PROTECTED)
10078     {
10079       /* Access granted if it occurs from within the package
10080          containing the class in which the protected member is
10081          declared */
10082       if (class_in_current_package (DECL_CONTEXT (member)))
10083         return 0;
10084
10085       /* If accessed with the form `super.member', then access is granted */
10086       if (from_super)
10087         return 0;
10088
10089       /* If where is active, access was made through a
10090          qualifier. Access is granted if the type of the qualifier is
10091          or is a sublass of the type the access made from (6.6.2.1.)  */
10092       if (where && !inherits_from_p (reference, where))
10093         return 1;
10094
10095       /* Otherwise, access is granted if occurring from the class where
10096          member is declared or a subclass of it. Find the right
10097          context to perform the check */
10098       if (PURE_INNER_CLASS_TYPE_P (reference))
10099         {
10100           while (INNER_CLASS_TYPE_P (reference))
10101             {
10102               if (inherits_from_p (reference, DECL_CONTEXT (member)))
10103                 return 0;
10104               reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10105             }
10106         }
10107       if (inherits_from_p (reference, DECL_CONTEXT (member)))
10108         return 0;
10109       return 1;
10110     }
10111
10112   /* Check access on private members. Access is granted only if it
10113      occurs from within the class in which it is declared -- that does
10114      it for innerclasses too. */
10115   if (access_flag & ACC_PRIVATE)
10116     {
10117       if (reference == DECL_CONTEXT (member))
10118         return 0;
10119       if (enclosing_context_p (reference, DECL_CONTEXT (member)))
10120         return 0;
10121       return 1;
10122     }
10123
10124   /* Default access are permitted only when occurring within the
10125      package in which the type (REFERENCE) is declared. In other words,
10126      REFERENCE is defined in the current package */
10127   if (ctxp->package)
10128     return !class_in_current_package (reference);
10129
10130   /* Otherwise, access is granted */
10131   return 0;
10132 }
10133
10134 /* Test deprecated decl access.  */
10135 static void
10136 check_deprecation (tree wfl, tree decl)
10137 {
10138   const char *file;
10139   tree elt;
10140
10141   if (! flag_deprecated)
10142     return;
10143
10144   /* We want to look at the element type of arrays here, so we strip
10145      all surrounding array types.  */
10146   if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10147     {
10148       elt = TREE_TYPE (decl);
10149       while (TYPE_ARRAY_P (elt))
10150         elt = TYPE_ARRAY_ELEMENT (elt);
10151       /* We'll end up with a pointer type, so we use TREE_TYPE to go
10152          to the record.  */
10153       decl = TYPE_NAME (TREE_TYPE (elt));
10154     }
10155   file = DECL_SOURCE_FILE (decl);
10156
10157   /* Complain if the field is deprecated and the file it was defined
10158      in isn't compiled at the same time the file which contains its
10159      use is */
10160   if (DECL_DEPRECATED (decl)
10161       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10162     {
10163       const char *the;
10164       switch (TREE_CODE (decl))
10165         {
10166         case FUNCTION_DECL:
10167           the = "method";
10168           break;
10169         case FIELD_DECL:
10170         case VAR_DECL:
10171           the = "field";
10172           break;
10173         case TYPE_DECL:
10174           parse_warning_context (wfl, "The class `%s' has been deprecated",
10175                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10176           return;
10177         default:
10178           abort ();
10179         }
10180       /* Don't issue a message if the context as been deprecated as a
10181          whole. */
10182       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10183         parse_warning_context
10184           (wfl, "The %s `%s' in class `%s' has been deprecated",
10185            the, lang_printable_name (decl, 0),
10186            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10187     }
10188 }
10189
10190 /* Returns 1 if class was declared in the current package, 0 otherwise */
10191
10192 static GTY(()) tree cicp_cache;
10193 static int
10194 class_in_current_package (tree class)
10195 {
10196   int qualified_flag;
10197   tree left;
10198
10199   if (cicp_cache == class)
10200     return 1;
10201
10202   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10203
10204   /* If the current package is empty and the name of CLASS is
10205      qualified, class isn't in the current package.  If there is a
10206      current package and the name of the CLASS is not qualified, class
10207      isn't in the current package */
10208   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10209     return 0;
10210
10211   /* If there is not package and the name of CLASS isn't qualified,
10212      they belong to the same unnamed package */
10213   if (!ctxp->package && !qualified_flag)
10214     return 1;
10215
10216   /* Compare the left part of the name of CLASS with the package name */
10217   breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10218   if (ctxp->package == left)
10219     {
10220       cicp_cache = class;
10221       return 1;
10222     }
10223   return 0;
10224 }
10225
10226 /* This function may generate code to access DECL from WHERE. This is
10227    done only if certain conditions meet.  */
10228
10229 static tree
10230 maybe_access_field (tree decl, tree where, tree type)
10231 {
10232   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10233       && !FIELD_STATIC (decl))
10234     decl = build_field_ref (where ? where : current_this,
10235                             (type ? type : DECL_CONTEXT (decl)),
10236                             DECL_NAME (decl));
10237   return decl;
10238 }
10239
10240 /* Build a method invocation, by patching PATCH. If non NULL
10241    and according to the situation, PRIMARY and WHERE may be
10242    used. IS_STATIC is set to 1 if the invoked function is static. */
10243
10244 static tree
10245 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10246                          int *is_static, tree *ret_decl)
10247 {
10248   tree wfl = TREE_OPERAND (patch, 0);
10249   tree args = TREE_OPERAND (patch, 1);
10250   tree name = EXPR_WFL_NODE (wfl);
10251   tree list;
10252   int is_static_flag = 0;
10253   int is_super_init = 0;
10254   tree this_arg = NULL_TREE;
10255   int is_array_clone_call = 0;
10256
10257   /* Should be overridden if everything goes well. Otherwise, if
10258      something fails, it should keep this value. It stop the
10259      evaluation of a bogus assignment. See java_complete_tree,
10260      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10261      evaluating an assignment */
10262   TREE_TYPE (patch) = error_mark_node;
10263
10264   /* Since lookup functions are messing with line numbers, save the
10265      context now.  */
10266   java_parser_context_save_global ();
10267
10268   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10269
10270   /* Resolution of qualified name, excluding constructors */
10271   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10272     {
10273       tree identifier, identifier_wfl, type, resolved;
10274       /* Extract the last IDENTIFIER of the qualified
10275          expression. This is a wfl and we will use it's location
10276          data during error report. */
10277       identifier_wfl = cut_identifier_in_qualified (wfl);
10278       identifier = EXPR_WFL_NODE (identifier_wfl);
10279
10280       /* Given the context, IDENTIFIER is syntactically qualified
10281          as a MethodName. We need to qualify what's before */
10282       qualify_ambiguous_name (wfl);
10283       resolved = resolve_field_access (wfl, NULL, NULL);
10284
10285       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10286          && FIELD_FINAL (resolved)
10287          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10288          && !flag_emit_class_files && !flag_emit_xref)
10289        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10290
10291       if (resolved == error_mark_node)
10292         PATCH_METHOD_RETURN_ERROR ();
10293
10294       type = GET_SKIP_TYPE (resolved);
10295       resolve_and_layout (type, NULL_TREE);
10296
10297       if (JPRIMITIVE_TYPE_P (type))
10298         {
10299           parse_error_context
10300             (identifier_wfl,
10301              "Can't invoke a method on primitive type `%s'",
10302              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10303           PATCH_METHOD_RETURN_ERROR ();
10304         }
10305
10306       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10307       args = nreverse (args);
10308
10309       /* We're resolving a call from a type */
10310       if (TREE_CODE (resolved) == TYPE_DECL)
10311         {
10312           if (CLASS_INTERFACE (resolved))
10313             {
10314               parse_error_context
10315                 (identifier_wfl,
10316                 "Can't make static reference to method `%s' in interface `%s'",
10317                  IDENTIFIER_POINTER (identifier),
10318                  IDENTIFIER_POINTER (name));
10319               PATCH_METHOD_RETURN_ERROR ();
10320             }
10321           if (list && !METHOD_STATIC (list))
10322             {
10323               char *fct_name = xstrdup (lang_printable_name (list, 0));
10324               parse_error_context
10325                 (identifier_wfl,
10326                  "Can't make static reference to method `%s %s' in class `%s'",
10327                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10328                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10329               free (fct_name);
10330               PATCH_METHOD_RETURN_ERROR ();
10331             }
10332         }
10333       else
10334         this_arg = primary = resolved;
10335
10336       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10337         is_array_clone_call = 1;
10338
10339       /* IDENTIFIER_WFL will be used to report any problem further */
10340       wfl = identifier_wfl;
10341     }
10342   /* Resolution of simple names, names generated after a primary: or
10343      constructors */
10344   else
10345     {
10346       tree class_to_search = NULL_TREE;
10347       int lc;                   /* Looking for Constructor */
10348
10349       /* We search constructor in their target class */
10350       if (CALL_CONSTRUCTOR_P (patch))
10351         {
10352           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10353             class_to_search = EXPR_WFL_NODE (wfl);
10354           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10355                    this_identifier_node)
10356             class_to_search = NULL_TREE;
10357           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10358                    super_identifier_node)
10359             {
10360               is_super_init = 1;
10361               if (CLASSTYPE_SUPER (current_class))
10362                 class_to_search =
10363                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10364               else
10365                 {
10366                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10367                   PATCH_METHOD_RETURN_ERROR ();
10368                 }
10369             }
10370
10371           /* Class to search is NULL if we're searching the current one */
10372           if (class_to_search)
10373             {
10374               class_to_search = resolve_and_layout (class_to_search, wfl);
10375
10376               if (!class_to_search)
10377                 {
10378                   parse_error_context
10379                     (wfl, "Class `%s' not found in type declaration",
10380                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10381                   PATCH_METHOD_RETURN_ERROR ();
10382                 }
10383
10384               /* Can't instantiate an abstract class, but we can
10385                  invoke it's constructor. It's use within the `new'
10386                  context is denied here. */
10387               if (CLASS_ABSTRACT (class_to_search)
10388                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10389                 {
10390                   parse_error_context
10391                     (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10392                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10393                   PATCH_METHOD_RETURN_ERROR ();
10394                 }
10395
10396               class_to_search = TREE_TYPE (class_to_search);
10397             }
10398           else
10399             class_to_search = current_class;
10400           lc = 1;
10401         }
10402       /* This is a regular search in the local class, unless an
10403          alternate class is specified. */
10404       else
10405         {
10406           if (where != NULL_TREE)
10407             class_to_search = where;
10408           else if (QUALIFIED_P (name))
10409             class_to_search = current_class;
10410           else
10411             {
10412               class_to_search = current_class;
10413
10414               for (;;)
10415                 {
10416                   if (has_method (class_to_search, name))
10417                     break;
10418                   if (! INNER_CLASS_TYPE_P (class_to_search))
10419                     {
10420                       parse_error_context (wfl,
10421                                            "No method named `%s' in scope",
10422                                            IDENTIFIER_POINTER (name));
10423                       PATCH_METHOD_RETURN_ERROR ();
10424                     }
10425                   class_to_search
10426                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10427                 }
10428             }
10429           lc = 0;
10430         }
10431
10432       /* NAME is a simple identifier or comes from a primary. Search
10433          in the class whose declaration contain the method being
10434          invoked. */
10435       resolve_and_layout (class_to_search, NULL_TREE);
10436
10437       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10438       /* Don't continue if no method were found, as the next statement
10439          can't be executed then. */
10440       if (!list)
10441         PATCH_METHOD_RETURN_ERROR ();
10442
10443       if (TYPE_ARRAY_P (class_to_search)
10444           && DECL_NAME (list) == get_identifier ("clone"))
10445         is_array_clone_call = 1;
10446
10447       /* Check for static reference if non static methods */
10448       if (check_for_static_method_reference (wfl, patch, list,
10449                                              class_to_search, primary))
10450         PATCH_METHOD_RETURN_ERROR ();
10451
10452       /* Check for inner classes creation from illegal contexts */
10453       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10454                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10455           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10456           && !DECL_INIT_P (current_function_decl))
10457         {
10458           parse_error_context
10459             (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10460              lang_printable_name (class_to_search, 0),
10461              (!current_this ? "" :
10462               "; an explicit one must be provided when creating this inner class"));
10463           PATCH_METHOD_RETURN_ERROR ();
10464         }
10465
10466       /* Non static methods are called with the current object extra
10467          argument. If patch a `new TYPE()', the argument is the value
10468          returned by the object allocator. If method is resolved as a
10469          primary, use the primary otherwise use the current THIS. */
10470       args = nreverse (args);
10471       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10472         {
10473           this_arg = primary ? primary : current_this;
10474
10475           /* If we're using an access method, things are different.
10476              There are two family of cases:
10477
10478              1) We're not generating bytecodes:
10479
10480              - LIST is non static. It's invocation is transformed from
10481                x(a1,...,an) into this$<n>.x(a1,....an).
10482              - LIST is static. It's invocation is transformed from
10483                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10484
10485              2) We're generating bytecodes:
10486
10487              - LIST is non static. It's invocation is transformed from
10488                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10489              - LIST is static. It's invocation is transformed from
10490                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10491
10492              Of course, this$<n> can be arbitrarily complex, ranging from
10493              this$0 (the immediate outer context) to
10494              access$0(access$0(...(this$0))).
10495
10496              maybe_use_access_method returns a nonzero value if the
10497              this_arg has to be moved into the (then generated) stub
10498              argument list. In the meantime, the selected function
10499              might have be replaced by a generated stub. */
10500           if (!primary &&
10501               maybe_use_access_method (is_super_init, &list, &this_arg))
10502             {
10503               args = tree_cons (NULL_TREE, this_arg, args);
10504               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10505             }
10506         }
10507     }
10508
10509   /* Merge point of all resolution schemes. If we have nothing, this
10510      is an error, already signaled */
10511   if (!list)
10512     PATCH_METHOD_RETURN_ERROR ();
10513
10514   /* Check accessibility, position the is_static flag, build and
10515      return the call */
10516   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10517                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10518                          NULL_TREE), from_super)
10519       /* Calls to clone() on array types are permitted as a special-case. */
10520       && !is_array_clone_call)
10521     {
10522       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10523       const char *const access =
10524         java_accstring_lookup (get_access_flags_from_decl (list));
10525       const char *const klass =
10526         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10527       const char *const refklass =
10528         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10529       const char *const what = (DECL_CONSTRUCTOR_P (list)
10530                                 ? "constructor" : "method");
10531       /* FIXME: WFL yields the wrong message here but I don't know
10532          what else to use.  */
10533       parse_error_context (wfl,
10534                            "Can't access %s %s `%s.%s' from `%s'",
10535                            access, what, klass, fct_name, refklass);
10536       PATCH_METHOD_RETURN_ERROR ();
10537     }
10538
10539   /* Deprecation check: check whether the method being invoked or the
10540      instance-being-created's type are deprecated.  */
10541   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10542     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10543   check_deprecation (wfl, list);
10544
10545   /* If invoking a innerclass constructor, there are hidden parameters
10546      to pass */
10547   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10548       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10549     {
10550       /* And make sure we add the accessed local variables to be saved
10551          in field aliases. */
10552       args = build_alias_initializer_parameter_list
10553         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10554
10555       /* Secretly pass the current_this/primary as a second argument */
10556       if (primary || current_this)
10557         {
10558           tree extra_arg;
10559           tree this_type = (current_this ?
10560                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10561           /* Method's (list) enclosing context */
10562           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10563           /* If we have a primary, use it. */
10564           if (primary)
10565             extra_arg = primary;
10566           /* The current `this' is an inner class but isn't a direct
10567              enclosing context for the inner class we're trying to
10568              create. Build an access to the proper enclosing context
10569              and use it. */
10570           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10571                    && this_type != TREE_TYPE (mec))
10572             {
10573
10574               extra_arg = build_access_to_thisn (current_class,
10575                                                  TREE_TYPE (mec), 0);
10576               extra_arg = java_complete_tree (extra_arg);
10577             }
10578           /* Otherwise, just use the current `this' as an enclosing
10579              context. */
10580           else
10581             extra_arg = current_this;
10582           args = tree_cons (NULL_TREE, extra_arg, args);
10583         }
10584       else
10585         args = tree_cons (NULL_TREE, integer_zero_node, args);
10586     }
10587
10588   /* This handles the situation where a constructor invocation needs
10589      to have an enclosing context passed as a second parameter (the
10590      constructor is one of an inner class). */
10591   if ((is_super_init ||
10592        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10593       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10594     {
10595       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10596       tree extra_arg =
10597         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10598       extra_arg = java_complete_tree (extra_arg);
10599       args = tree_cons (NULL_TREE, extra_arg, args);
10600     }
10601
10602   is_static_flag = METHOD_STATIC (list);
10603   if (! is_static_flag && this_arg != NULL_TREE)
10604     args = tree_cons (NULL_TREE, this_arg, args);
10605
10606   /* In the context of an explicit constructor invocation, we can't
10607      invoke any method relying on `this'. Exceptions are: we're
10608      invoking a static function, primary exists and is not the current
10609      this, we're creating a new object. */
10610   if (ctxp->explicit_constructor_p
10611       && !is_static_flag
10612       && (!primary || primary == current_this)
10613       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10614     {
10615       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10616       PATCH_METHOD_RETURN_ERROR ();
10617     }
10618   java_parser_context_restore_global ();
10619   if (is_static)
10620     *is_static = is_static_flag;
10621   /* Sometimes, we want the decl of the selected method. Such as for
10622      EH checking */
10623   if (ret_decl)
10624     *ret_decl = list;
10625   patch = patch_invoke (patch, list, args);
10626
10627   /* Now is a good time to insert the call to finit$ */
10628   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10629     {
10630       tree finit_parms, finit_call;
10631
10632       /* Prepare to pass hidden parameters to finit$, if any. */
10633       finit_parms = build_alias_initializer_parameter_list
10634         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10635
10636       finit_call =
10637         build_method_invocation (build_wfl_node (finit_identifier_node),
10638                                  finit_parms);
10639
10640       /* Generate the code used to initialize fields declared with an
10641          initialization statement and build a compound statement along
10642          with the super constructor invocation. */
10643       CAN_COMPLETE_NORMALLY (patch) = 1;
10644       patch = build (COMPOUND_EXPR, void_type_node, patch,
10645                      java_complete_tree (finit_call));
10646     }
10647   return patch;
10648 }
10649
10650 /* Check that we're not trying to do a static reference to a method in
10651    non static method. Return 1 if it's the case, 0 otherwise. */
10652
10653 static int
10654 check_for_static_method_reference (tree wfl, tree node, tree method,
10655                                    tree where, tree primary)
10656 {
10657   if (METHOD_STATIC (current_function_decl)
10658       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10659     {
10660       char *fct_name = xstrdup (lang_printable_name (method, 0));
10661       parse_error_context
10662         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10663          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10664          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10665       free (fct_name);
10666       return 1;
10667     }
10668   return 0;
10669 }
10670
10671 /* Fix the invocation of *MDECL if necessary in the case of a
10672    invocation from an inner class. *THIS_ARG might be modified
10673    appropriately and an alternative access to *MDECL might be
10674    returned.  */
10675
10676 static int
10677 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10678 {
10679   tree ctx;
10680   tree md = *mdecl, ta = *this_arg;
10681   int to_return = 0;
10682   int non_static_context = !METHOD_STATIC (md);
10683
10684   if (is_super_init
10685       || DECL_CONTEXT (md) == current_class
10686       || !PURE_INNER_CLASS_TYPE_P (current_class)
10687       || DECL_FINIT_P (md)
10688       || DECL_INSTINIT_P (md))
10689     return 0;
10690
10691   /* If we're calling a method found in an enclosing class, generate
10692      what it takes to retrieve the right this. Don't do that if we're
10693      invoking a static method. Note that if MD's type is unrelated to
10694      CURRENT_CLASS, then the current this can be used. */
10695
10696   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10697     {
10698       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10699       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10700         {
10701           ta = build_current_thisn (current_class);
10702           ta = build_wfl_node (ta);
10703         }
10704       else
10705         {
10706           tree type = ctx;
10707           while (type)
10708             {
10709               maybe_build_thisn_access_method (type);
10710               if (inherits_from_p (type, DECL_CONTEXT (md)))
10711                 {
10712                   ta = build_access_to_thisn (ctx, type, 0);
10713                   break;
10714                 }
10715               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10716                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10717             }
10718         }
10719       ta = java_complete_tree (ta);
10720     }
10721
10722   /* We might have to use an access method to get to MD. We can
10723      break the method access rule as far as we're not generating
10724      bytecode */
10725   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10726     {
10727       md = build_outer_method_access_method (md);
10728       to_return = 1;
10729     }
10730
10731   *mdecl = md;
10732   *this_arg = ta;
10733
10734   /* Returning a nonzero value indicates we were doing a non static
10735      method invocation that is now a static invocation. It will have
10736      callee displace `this' to insert it in the regular argument
10737      list. */
10738   return (non_static_context && to_return);
10739 }
10740
10741 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10742    mode.  */
10743
10744 static tree
10745 patch_invoke (tree patch, tree method, tree args)
10746 {
10747   tree dtable, func;
10748   tree original_call, t, ta;
10749   tree check = NULL_TREE;
10750
10751   /* Last step for args: convert build-in types. If we're dealing with
10752      a new TYPE() type call, the first argument to the constructor
10753      isn't found in the incoming argument list, but delivered by
10754      `new' */
10755   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10756   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10757     t = TREE_CHAIN (t);
10758   for (ta = args; t != end_params_node && ta;
10759        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10760     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10761         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10762       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10763
10764   /* Resolve unresolved returned type issues */
10765   t = TREE_TYPE (TREE_TYPE (method));
10766   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10767     resolve_and_layout (TREE_TYPE (t), NULL);
10768
10769   if (flag_emit_class_files || flag_emit_xref)
10770     func = method;
10771   else
10772     {
10773       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10774         {
10775         case INVOKE_VIRTUAL:
10776           dtable = invoke_build_dtable (0, args);
10777           func = build_invokevirtual (dtable, method);
10778           break;
10779
10780         case INVOKE_NONVIRTUAL:
10781           /* If the object for the method call is null, we throw an
10782              exception.  We don't do this if the object is the current
10783              method's `this'.  In other cases we just rely on an
10784              optimization pass to eliminate redundant checks.  */
10785           if (TREE_VALUE (args) != current_this)
10786             {
10787               /* We use a save_expr here to make sure we only evaluate
10788                  the new `self' expression once.  */
10789               tree save_arg = save_expr (TREE_VALUE (args));
10790               TREE_VALUE (args) = save_arg;
10791               check = java_check_reference (save_arg, 1);
10792             }
10793           /* Fall through.  */
10794
10795         case INVOKE_SUPER:
10796         case INVOKE_STATIC:
10797           {
10798             tree signature = build_java_signature (TREE_TYPE (method));
10799             func = build_known_method_ref (method, TREE_TYPE (method),
10800                                            DECL_CONTEXT (method),
10801                                            signature, args);
10802           }
10803           break;
10804
10805         case INVOKE_INTERFACE:
10806           dtable = invoke_build_dtable (1, args);
10807           func = build_invokeinterface (dtable, method);
10808           break;
10809
10810         default:
10811           abort ();
10812         }
10813
10814       /* Ensure self_type is initialized, (invokestatic). FIXME */
10815       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10816     }
10817
10818   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10819   TREE_OPERAND (patch, 0) = func;
10820   TREE_OPERAND (patch, 1) = args;
10821   patch = check_for_builtin (method, patch);
10822   original_call = patch;
10823
10824   /* We're processing a `new TYPE ()' form. New is called and its
10825      returned value is the first argument to the constructor. We build
10826      a COMPOUND_EXPR and use saved expression so that the overall NEW
10827      expression value is a pointer to a newly created and initialized
10828      class. */
10829   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10830     {
10831       tree class = DECL_CONTEXT (method);
10832       tree c1, saved_new, size, new;
10833       tree alloc_node;
10834
10835       if (flag_emit_class_files || flag_emit_xref)
10836         {
10837           TREE_TYPE (patch) = build_pointer_type (class);
10838           return patch;
10839         }
10840       if (!TYPE_SIZE (class))
10841         safe_layout_class (class);
10842       size = size_in_bytes (class);
10843       alloc_node =
10844         (class_has_finalize_method (class) ? alloc_object_node
10845                                            : alloc_no_finalizer_node);
10846       new = build (CALL_EXPR, promote_type (class),
10847                    build_address_of (alloc_node),
10848                    tree_cons (NULL_TREE, build_class_ref (class),
10849                               build_tree_list (NULL_TREE,
10850                                                size_in_bytes (class))),
10851                    NULL_TREE);
10852       saved_new = save_expr (new);
10853       c1 = build_tree_list (NULL_TREE, saved_new);
10854       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10855       TREE_OPERAND (original_call, 1) = c1;
10856       TREE_SET_CODE (original_call, CALL_EXPR);
10857       patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10858     }
10859
10860   /* If CHECK is set, then we are building a check to see if the object
10861      is NULL.  */
10862   if (check != NULL_TREE)
10863     {
10864       /* We have to call force_evaluation_order now because creating a
10865          COMPOUND_EXPR wraps the arg list in a way that makes it
10866          unrecognizable by force_evaluation_order later.  Yuk.  */
10867       patch = build (COMPOUND_EXPR, TREE_TYPE (patch), check,
10868                      force_evaluation_order (patch));
10869       TREE_SIDE_EFFECTS (patch) = 1;
10870     }
10871
10872   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10873      put it as the first expression of a COMPOUND_EXPR. The second
10874      expression being an empty statement to be later patched if
10875      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10876      the VALUE is the compound) in a hashtable and return a
10877      COMPOUND_EXPR built so that the result of the evaluation of the
10878      original PATCH node is returned. */
10879   if (STATIC_CLASS_INIT_OPT_P ()
10880       && current_function_decl && METHOD_STATIC (method))
10881     {
10882       tree list;
10883       tree fndecl = current_function_decl;
10884       /* We have to call force_evaluation_order now because creating a
10885          COMPOUND_EXPR wraps the arg list in a way that makes it
10886          unrecognizable by force_evaluation_order later.  Yuk.  */
10887       tree save = save_expr (force_evaluation_order (patch));
10888       tree type = TREE_TYPE (patch);
10889
10890       patch = build (COMPOUND_EXPR, type, save, empty_stmt_node);
10891       list = tree_cons (method, patch,
10892                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10893
10894       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10895
10896       patch = build (COMPOUND_EXPR, type, patch, save);
10897     }
10898
10899   return patch;
10900 }
10901
10902 static int
10903 invocation_mode (tree method, int super)
10904 {
10905   int access = get_access_flags_from_decl (method);
10906
10907   if (super)
10908     return INVOKE_SUPER;
10909
10910   if (access & ACC_STATIC)
10911     return INVOKE_STATIC;
10912
10913   /* We have to look for a constructor before we handle nonvirtual
10914      calls; otherwise the constructor will look nonvirtual.  */
10915   if (DECL_CONSTRUCTOR_P (method))
10916     return INVOKE_STATIC;
10917
10918   if (access & ACC_FINAL || access & ACC_PRIVATE)
10919     return INVOKE_NONVIRTUAL;
10920
10921   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10922     return INVOKE_NONVIRTUAL;
10923
10924   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10925     return INVOKE_INTERFACE;
10926
10927   return INVOKE_VIRTUAL;
10928 }
10929
10930 /* Retrieve a refined list of matching methods. It covers the step
10931    15.11.2 (Compile-Time Step 2) */
10932
10933 static tree
10934 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
10935 {
10936   tree atl = end_params_node;           /* Arg Type List */
10937   tree method, signature, list, node;
10938   const char *candidates;               /* Used for error report */
10939   char *dup;
10940
10941   /* Fix the arguments */
10942   for (node = arg_list; node; node = TREE_CHAIN (node))
10943     {
10944       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10945       /* Non primitive type may have to be resolved */
10946       if (!JPRIMITIVE_TYPE_P (current_arg))
10947         resolve_and_layout (current_arg, NULL_TREE);
10948       /* And promoted */
10949       if (TREE_CODE (current_arg) == RECORD_TYPE)
10950         current_arg = promote_type (current_arg);
10951       atl = tree_cons (NULL_TREE, current_arg, atl);
10952     }
10953
10954   /* Presto. If we're dealing with an anonymous class and a
10955      constructor call, generate the right constructor now, since we
10956      know the arguments' types. */
10957
10958   if (lc && ANONYMOUS_CLASS_P (class))
10959     {
10960       tree saved_current_class;
10961       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10962       saved_current_class = current_class;
10963       current_class = class;
10964       fix_constructors (mdecl);
10965       current_class = saved_current_class;
10966     }
10967
10968   /* Find all candidates and then refine the list, searching for the
10969      most specific method. */
10970   list = find_applicable_accessible_methods_list (lc, class, name, atl);
10971   list = find_most_specific_methods_list (list);
10972   if (list && !TREE_CHAIN (list))
10973     return TREE_VALUE (list);
10974
10975   /* Issue an error. List candidates if any. Candidates are listed
10976      only if accessible (non accessible methods may end-up here for
10977      the sake of a better error report). */
10978   candidates = NULL;
10979   if (list)
10980     {
10981       tree current;
10982       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
10983       for (current = list; current; current = TREE_CHAIN (current))
10984         {
10985           tree cm = TREE_VALUE (current);
10986           char string [4096];
10987           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
10988             continue;
10989           sprintf
10990             (string, "  `%s' in `%s'%s",
10991              get_printable_method_name (cm),
10992              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
10993              (TREE_CHAIN (current) ? "\n" : ""));
10994           obstack_grow (&temporary_obstack, string, strlen (string));
10995         }
10996       obstack_1grow (&temporary_obstack, '\0');
10997       candidates = obstack_finish (&temporary_obstack);
10998     }
10999   /* Issue the error message */
11000   method = make_node (FUNCTION_TYPE);
11001   TYPE_ARG_TYPES (method) = atl;
11002   signature = build_java_argument_signature (method);
11003   dup = xstrdup (lang_printable_name (class, 0));
11004   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
11005                        (lc ? "constructor" : "method"),
11006                        (lc ? dup : IDENTIFIER_POINTER (name)),
11007                        IDENTIFIER_POINTER (signature), dup,
11008                        (candidates ? candidates : ""));
11009   free (dup);
11010   return NULL_TREE;
11011 }
11012
11013 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
11014    when we're looking for a constructor. */
11015
11016 static tree
11017 find_applicable_accessible_methods_list (int lc, tree class, tree name,
11018                                          tree arglist)
11019 {
11020   static htab_t searched_classes;
11021   static int search_not_done = 0;
11022   tree list = NULL_TREE, all_list = NULL_TREE;
11023
11024   /* Check the hash table to determine if this class has been searched
11025      already. */
11026   if (searched_classes)
11027     {
11028       if (htab_find (searched_classes, class) != NULL)
11029         return NULL;
11030     }
11031   else
11032     {
11033       searched_classes = htab_create (10, htab_hash_pointer,
11034                                       htab_eq_pointer, NULL);
11035     }
11036
11037   search_not_done++;
11038   *htab_find_slot (searched_classes, class, INSERT) = class;
11039
11040   if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
11041     {
11042       load_class (class, 1);
11043       safe_layout_class (class);
11044     }
11045
11046   /* Search interfaces */
11047   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11048       && CLASS_INTERFACE (TYPE_NAME (class)))
11049     {
11050       int i, n;
11051       tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11052       search_applicable_methods_list (lc, TYPE_METHODS (class),
11053                                       name, arglist, &list, &all_list);
11054       n = TREE_VEC_LENGTH (basetype_vec);
11055       for (i = 1; i < n; i++)
11056         {
11057           tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11058           tree rlist;
11059
11060           rlist = find_applicable_accessible_methods_list (lc,  t, name,
11061                                                            arglist);
11062           list = chainon (rlist, list);
11063         }
11064     }
11065   /* Search classes */
11066   else
11067     {
11068       search_applicable_methods_list (lc, TYPE_METHODS (class),
11069                                       name, arglist, &list, &all_list);
11070
11071       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11072          that we only search in class. Note that we should have found
11073          something at this point. */
11074       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11075         {
11076           lc = 1;
11077           if (!list)
11078             abort ();
11079         }
11080
11081       /* We must search all interfaces of this class */
11082       if (!lc)
11083       {
11084         tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11085         int n = TREE_VEC_LENGTH (basetype_vec), i;
11086         for (i = 1; i < n; i++)
11087           {
11088             tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11089             if (t != object_type_node)
11090               {
11091                 tree rlist
11092                   = find_applicable_accessible_methods_list (lc, t,
11093                                                              name, arglist);
11094                 list = chainon (rlist, list);
11095               }
11096           }
11097       }
11098
11099       /* Search superclass */
11100       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11101         {
11102           tree rlist;
11103           class = CLASSTYPE_SUPER (class);
11104           rlist = find_applicable_accessible_methods_list (lc, class,
11105                                                            name, arglist);
11106           list = chainon (rlist, list);
11107         }
11108     }
11109
11110   search_not_done--;
11111
11112   /* We're done. Reset the searched classes list and finally search
11113      java.lang.Object if it wasn't searched already. */
11114   if (!search_not_done)
11115     {
11116       if (!lc
11117           && TYPE_METHODS (object_type_node)
11118           && htab_find (searched_classes, object_type_node) == NULL)
11119         {
11120           search_applicable_methods_list (lc,
11121                                           TYPE_METHODS (object_type_node),
11122                                           name, arglist, &list, &all_list);
11123         }
11124       htab_delete (searched_classes);
11125       searched_classes = NULL;
11126     }
11127
11128   /* Either return the list obtained or all selected (but
11129      inaccessible) methods for better error report. */
11130   return (!list ? all_list : list);
11131 }
11132
11133 /* Effectively search for the appropriate method in method */
11134
11135 static void
11136 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11137                                 tree *list, tree *all_list)
11138 {
11139   for (; method; method = TREE_CHAIN (method))
11140     {
11141       /* When dealing with constructor, stop here, otherwise search
11142          other classes */
11143       if (lc && !DECL_CONSTRUCTOR_P (method))
11144         continue;
11145       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11146                        || (DECL_NAME (method) != name)))
11147         continue;
11148
11149       if (argument_types_convertible (method, arglist))
11150         {
11151           /* Retain accessible methods only */
11152           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11153                                  method, NULL_TREE, 0))
11154             *list = tree_cons (NULL_TREE, method, *list);
11155           else
11156             /* Also retain all selected method here */
11157             *all_list = tree_cons (NULL_TREE, method, *list);
11158         }
11159     }
11160 }
11161
11162 /* 15.11.2.2 Choose the Most Specific Method */
11163
11164 static tree
11165 find_most_specific_methods_list (tree list)
11166 {
11167   int max = 0;
11168   int abstract, candidates;
11169   tree current, new_list = NULL_TREE;
11170   for (current = list; current; current = TREE_CHAIN (current))
11171     {
11172       tree method;
11173       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11174
11175       for (method = list; method; method = TREE_CHAIN (method))
11176         {
11177           tree method_v, current_v;
11178           /* Don't test a method against itself */
11179           if (method == current)
11180             continue;
11181
11182           method_v = TREE_VALUE (method);
11183           current_v = TREE_VALUE (current);
11184
11185           /* Compare arguments and location where methods where declared */
11186           if (argument_types_convertible (method_v, current_v))
11187             {
11188               if (valid_method_invocation_conversion_p
11189                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11190                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11191                       && enclosing_context_p (DECL_CONTEXT (method_v),
11192                                               DECL_CONTEXT (current_v))))
11193                 {
11194                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
11195                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11196                   max = (v > max ? v : max);
11197                 }
11198             }
11199         }
11200     }
11201
11202   /* Review the list and select the maximally specific methods */
11203   for (current = list, abstract = -1, candidates = -1;
11204        current; current = TREE_CHAIN (current))
11205     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11206       {
11207         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11208         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11209         candidates++;
11210       }
11211
11212   /* If we have several and they're all abstract, just pick the
11213      closest one. */
11214   if (candidates > 0 && candidates == abstract)
11215     {
11216       /* FIXME: merge the throws clauses.  There is no convenient way
11217          to do this in gcj right now, since ideally we'd like to
11218          introduce a new METHOD_DECL here, but that is really not
11219          possible.  */
11220       new_list = nreverse (new_list);
11221       TREE_CHAIN (new_list) = NULL_TREE;
11222       return new_list;
11223     }
11224
11225   /* We have several (we couldn't find a most specific), all but one
11226      are abstract, we pick the only non abstract one. */
11227   if (candidates > 0 && (candidates == abstract+1))
11228     {
11229       for (current = new_list; current; current = TREE_CHAIN (current))
11230         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11231           {
11232             TREE_CHAIN (current) = NULL_TREE;
11233             new_list = current;
11234           }
11235     }
11236
11237   /* If we can't find one, lower expectations and try to gather multiple
11238      maximally specific methods */
11239   while (!new_list && max)
11240     {
11241       while (--max > 0)
11242         {
11243           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11244             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11245         }
11246     }
11247
11248   return new_list;
11249 }
11250
11251 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11252    converted by method invocation conversion (5.3) to the type of the
11253    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11254    to change less often than M1. */
11255
11256 static GTY(()) tree m2_arg_value;
11257 static GTY(()) tree m2_arg_cache;
11258
11259 static int
11260 argument_types_convertible (tree m1, tree m2_or_arglist)
11261 {
11262   tree m1_arg, m2_arg;
11263
11264   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11265
11266   if (m2_arg_value == m2_or_arglist)
11267     m2_arg = m2_arg_cache;
11268   else
11269     {
11270       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11271          argument types */
11272       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11273         {
11274           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11275           if (!METHOD_STATIC (m2_or_arglist))
11276             m2_arg = TREE_CHAIN (m2_arg);
11277         }
11278       else
11279         m2_arg = m2_or_arglist;
11280
11281       m2_arg_value = m2_or_arglist;
11282       m2_arg_cache = m2_arg;
11283     }
11284
11285   while (m1_arg != end_params_node && m2_arg != end_params_node)
11286     {
11287       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11288       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11289                                                  TREE_VALUE (m2_arg)))
11290         break;
11291       m1_arg = TREE_CHAIN (m1_arg);
11292       m2_arg = TREE_CHAIN (m2_arg);
11293     }
11294   return m1_arg == end_params_node && m2_arg == end_params_node;
11295 }
11296
11297 /* Qualification routines */
11298
11299 /* Given a name x.y.z, look up x locally.  If it's found, save the
11300    decl.  If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11301    so that we later try and load the appropriate classes.  */
11302 static void
11303 qualify_ambiguous_name (tree id)
11304 {
11305   tree name, decl;
11306
11307   /* We inspect the first item of the qualification list.  As a sanity
11308      check, make sure that it is an identfier node.  */
11309   tree qual = EXPR_WFL_QUALIFICATION (id);
11310   tree qual_wfl = QUAL_WFL (qual);
11311
11312   if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11313     return;
11314
11315   name = EXPR_WFL_NODE (qual_wfl);
11316
11317   /* If we don't have an identifier, or we have a 'this' or 'super',
11318      then field access processing is all we need : there is nothing
11319      for us to do.  */
11320   if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11321       name == this_identifier_node ||
11322       name == super_identifier_node)
11323     return;
11324
11325   /* If name appears within the scope of a local variable declaration
11326      or parameter declaration, or is a field within an enclosing
11327      class, then it is an expression name.  Save the decl and let
11328      resolve_field_access do it's work.  */
11329   if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11330       (decl = lookup_field_wrapper (current_class, name)))
11331     {
11332       QUAL_RESOLUTION (qual) = decl;
11333       return;
11334     }
11335
11336   /* If name is a known class name (either declared or imported), mark
11337      us as a type name.  */
11338   if ((decl = resolve_and_layout (name, NULL_TREE)))
11339     {
11340       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11341       QUAL_RESOLUTION (qual) = decl;
11342     }
11343
11344   /* Check here that NAME isn't declared by more than one
11345      type-import-on-demand declaration of the compilation unit
11346      containing NAME. FIXME */
11347
11348   /* We couldn't find a declaration for the name.  Assume for now that
11349      we have a qualified class name that needs to be loaded from an
11350      external class file.  */
11351   else
11352     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11353
11354   /* Propagate the qualification across other components of the
11355      qualified name */
11356   for (qual = TREE_CHAIN (qual); qual;
11357        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11358     {
11359       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11360         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11361     }
11362
11363   /* Store the global qualification for the ambiguous part of ID back
11364      into ID fields */
11365   if (RESOLVE_TYPE_NAME_P (qual_wfl))
11366     RESOLVE_TYPE_NAME_P (id) = 1;
11367   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11368     RESOLVE_PACKAGE_NAME_P (id) = 1;
11369 }
11370
11371 static int
11372 breakdown_qualified (tree *left, tree *right, tree source)
11373 {
11374   char *p, *base;
11375   int l = IDENTIFIER_LENGTH (source);
11376
11377   base = alloca (l + 1);
11378   memcpy (base, IDENTIFIER_POINTER (source), l + 1);
11379
11380   /* Breakdown NAME into REMAINDER . IDENTIFIER.  */
11381   p = base + l - 1;
11382   while (*p != '.' && p != base)
11383     p--;
11384
11385   /* We didn't find a '.'. Return an error.  */
11386   if (p == base)
11387     return 1;
11388
11389   *p = '\0';
11390   if (right)
11391     *right = get_identifier (p+1);
11392   *left = get_identifier (base);
11393
11394   return 0;
11395 }
11396
11397 /* Return TRUE if two classes are from the same package. */
11398
11399 static int
11400 in_same_package (tree name1, tree name2)
11401 {
11402   tree tmp;
11403   tree pkg1;
11404   tree pkg2;
11405
11406   if (TREE_CODE (name1) == TYPE_DECL)
11407     name1 = DECL_NAME (name1);
11408   if (TREE_CODE (name2) == TYPE_DECL)
11409     name2 = DECL_NAME (name2);
11410
11411   if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
11412     /* One in empty package. */
11413     return 0;
11414
11415   if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
11416     /* Both in empty package. */
11417     return 1;
11418
11419   breakdown_qualified (&pkg1, &tmp, name1);
11420   breakdown_qualified (&pkg2, &tmp, name2);
11421
11422   return (pkg1 == pkg2);
11423 }
11424
11425 /* Patch tree nodes in a function body. When a BLOCK is found, push
11426    local variable decls if present.
11427    Same as java_complete_lhs, but does resolve static finals to values. */
11428
11429 static tree
11430 java_complete_tree (tree node)
11431 {
11432   node = java_complete_lhs (node);
11433   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11434       && DECL_INITIAL (node) != NULL_TREE
11435       && !flag_emit_xref)
11436     {
11437       tree value = fold_constant_for_init (node, node);
11438       if (value != NULL_TREE)
11439         return value;
11440     }
11441   return node;
11442 }
11443
11444 static tree
11445 java_stabilize_reference (tree node)
11446 {
11447   if (TREE_CODE (node) == COMPOUND_EXPR)
11448     {
11449       tree op0 = TREE_OPERAND (node, 0);
11450       tree op1 = TREE_OPERAND (node, 1);
11451       TREE_OPERAND (node, 0) = save_expr (op0);
11452       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11453       return node;
11454     }
11455   return stabilize_reference (node);
11456 }
11457
11458 /* Patch tree nodes in a function body. When a BLOCK is found, push
11459    local variable decls if present.
11460    Same as java_complete_tree, but does not resolve static finals to values. */
11461
11462 static tree
11463 java_complete_lhs (tree node)
11464 {
11465   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11466   int flag;
11467
11468   /* CONVERT_EXPR always has its type set, even though it needs to be
11469      worked out. */
11470   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11471     return node;
11472
11473   /* The switch block implements cases processing container nodes
11474      first.  Contained nodes are always written back. Leaves come
11475      next and return a value. */
11476   switch (TREE_CODE (node))
11477     {
11478     case BLOCK:
11479
11480       /* 1- Block section.
11481          Set the local values on decl names so we can identify them
11482          faster when they're referenced. At that stage, identifiers
11483          are legal so we don't check for declaration errors. */
11484       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11485         {
11486           DECL_CONTEXT (cn) = current_function_decl;
11487           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11488         }
11489       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11490           CAN_COMPLETE_NORMALLY (node) = 1;
11491       else
11492         {
11493           tree stmt = BLOCK_EXPR_BODY (node);
11494           tree *ptr;
11495           int error_seen = 0;
11496           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11497             {
11498               /* Re-order from (((A; B); C); ...; Z) to
11499                  (A; (B; (C ; (...; Z)))).
11500                  This makes it easier to scan the statements left-to-right
11501                  without using recursion (which might overflow the stack
11502                  if the block has many statements. */
11503               for (;;)
11504                 {
11505                   tree left = TREE_OPERAND (stmt, 0);
11506                   if (TREE_CODE (left) != COMPOUND_EXPR)
11507                     break;
11508                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11509                   TREE_OPERAND (left, 1) = stmt;
11510                   stmt = left;
11511                 }
11512               BLOCK_EXPR_BODY (node) = stmt;
11513             }
11514
11515           /* Now do the actual complete, without deep recursion for
11516              long blocks. */
11517           ptr = &BLOCK_EXPR_BODY (node);
11518           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11519                  && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
11520             {
11521               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11522               tree *next = &TREE_OPERAND (*ptr, 1);
11523               TREE_OPERAND (*ptr, 0) = cur;
11524               if (cur == empty_stmt_node)
11525                 {
11526                   /* Optimization;  makes it easier to detect empty bodies.
11527                      Most useful for <clinit> with all-constant initializer. */
11528                   *ptr = *next;
11529                   continue;
11530                 }
11531               if (TREE_CODE (cur) == ERROR_MARK)
11532                 error_seen++;
11533               else if (! CAN_COMPLETE_NORMALLY (cur))
11534                 {
11535                   wfl_op2 = *next;
11536                   for (;;)
11537                     {
11538                       if (TREE_CODE (wfl_op2) == BLOCK)
11539                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11540                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11541                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11542                       else
11543                         break;
11544                     }
11545                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11546                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11547                     unreachable_stmt_error (*ptr);
11548                 }
11549               if (TREE_TYPE (*ptr) == NULL_TREE)
11550                 TREE_TYPE (*ptr) = void_type_node;
11551               ptr = next;
11552             }
11553           *ptr = java_complete_tree (*ptr);
11554
11555           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11556             return error_mark_node;
11557           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11558         }
11559       /* Turn local bindings to null */
11560       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11561         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11562
11563       TREE_TYPE (node) = void_type_node;
11564       break;
11565
11566       /* 2- They are expressions but ultimately deal with statements */
11567
11568     case THROW_EXPR:
11569       wfl_op1 = TREE_OPERAND (node, 0);
11570       COMPLETE_CHECK_OP_0 (node);
11571       /* 14.19 A throw statement cannot complete normally. */
11572       CAN_COMPLETE_NORMALLY (node) = 0;
11573       return patch_throw_statement (node, wfl_op1);
11574
11575     case SYNCHRONIZED_EXPR:
11576       wfl_op1 = TREE_OPERAND (node, 0);
11577       return patch_synchronized_statement (node, wfl_op1);
11578
11579     case TRY_EXPR:
11580       return patch_try_statement (node);
11581
11582     case TRY_FINALLY_EXPR:
11583       COMPLETE_CHECK_OP_0 (node);
11584       COMPLETE_CHECK_OP_1 (node);
11585       /* Reduce try/finally nodes with an empty try block.  */
11586       if (TREE_OPERAND (node, 0) == empty_stmt_node
11587           || BLOCK_EMPTY_P (TREE_OPERAND (node, 0)))
11588         return TREE_OPERAND (node, 1);
11589       /* Likewise for an empty finally block.  */
11590       if (TREE_OPERAND (node, 1) == empty_stmt_node
11591           || BLOCK_EMPTY_P (TREE_OPERAND (node, 1)))
11592         return TREE_OPERAND (node, 0);
11593       CAN_COMPLETE_NORMALLY (node)
11594         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11595            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11596       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11597       return node;
11598
11599     case LABELED_BLOCK_EXPR:
11600       PUSH_LABELED_BLOCK (node);
11601       if (LABELED_BLOCK_BODY (node))
11602         COMPLETE_CHECK_OP_1 (node);
11603       TREE_TYPE (node) = void_type_node;
11604       POP_LABELED_BLOCK ();
11605
11606       if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
11607         {
11608           LABELED_BLOCK_BODY (node) = NULL_TREE;
11609           CAN_COMPLETE_NORMALLY (node) = 1;
11610         }
11611       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11612         CAN_COMPLETE_NORMALLY (node) = 1;
11613       return node;
11614
11615     case EXIT_BLOCK_EXPR:
11616       /* We don't complete operand 1, because it's the return value of
11617          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11618       return patch_bc_statement (node);
11619
11620     case CASE_EXPR:
11621       cn = java_complete_tree (TREE_OPERAND (node, 0));
11622       if (cn == error_mark_node)
11623         return cn;
11624
11625       /* First, the case expression must be constant. Values of final
11626          fields are accepted. */
11627       cn = fold (cn);
11628       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11629           && JDECL_P (TREE_OPERAND (cn, 1))
11630           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11631           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11632         {
11633           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11634                                        TREE_OPERAND (cn, 1));
11635         }
11636       /* Accept final locals too. */
11637       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn))
11638         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11639
11640       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11641         {
11642           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11643           parse_error_context (node, "Constant expression required");
11644           return error_mark_node;
11645         }
11646
11647       nn = ctxp->current_loop;
11648
11649       /* It must be assignable to the type of the switch expression. */
11650       if (!try_builtin_assignconv (NULL_TREE,
11651                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11652         {
11653           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11654           parse_error_context
11655             (wfl_operator,
11656              "Incompatible type for case. Can't convert `%s' to `int'",
11657              lang_printable_name (TREE_TYPE (cn), 0));
11658           return error_mark_node;
11659         }
11660
11661       cn = fold (convert (int_type_node, cn));
11662       TREE_CONSTANT_OVERFLOW (cn) = 0;
11663       CAN_COMPLETE_NORMALLY (cn) = 1;
11664
11665       /* Save the label on a list so that we can later check for
11666          duplicates.  */
11667       case_label_list = tree_cons (node, cn, case_label_list);
11668
11669       /* Multiple instance of a case label bearing the same value is
11670          checked later. The case expression is all right so far. */
11671       if (TREE_CODE (cn) == VAR_DECL)
11672         cn = DECL_INITIAL (cn);
11673       TREE_OPERAND (node, 0) = cn;
11674       TREE_TYPE (node) = void_type_node;
11675       CAN_COMPLETE_NORMALLY (node) = 1;
11676       TREE_SIDE_EFFECTS (node) = 1;
11677       break;
11678
11679     case DEFAULT_EXPR:
11680       nn = ctxp->current_loop;
11681       /* Only one default label is allowed per switch statement */
11682       if (SWITCH_HAS_DEFAULT (nn))
11683         {
11684           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11685           parse_error_context (wfl_operator,
11686                                "Duplicate case label: `default'");
11687           return error_mark_node;
11688         }
11689       else
11690         SWITCH_HAS_DEFAULT (nn) = 1;
11691       TREE_TYPE (node) = void_type_node;
11692       TREE_SIDE_EFFECTS (node) = 1;
11693       CAN_COMPLETE_NORMALLY (node) = 1;
11694       break;
11695
11696     case SWITCH_EXPR:
11697     case LOOP_EXPR:
11698       PUSH_LOOP (node);
11699       /* Check whether the loop was enclosed in a labeled
11700          statement. If not, create one, insert the loop in it and
11701          return the node */
11702       nn = patch_loop_statement (node);
11703
11704       /* Anyways, walk the body of the loop */
11705       if (TREE_CODE (node) == LOOP_EXPR)
11706         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11707       /* Switch statement: walk the switch expression and the cases */
11708       else
11709         node = patch_switch_statement (node);
11710
11711       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11712         nn = error_mark_node;
11713       else
11714         {
11715           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11716           /* If we returned something different, that's because we
11717              inserted a label. Pop the label too. */
11718           if (nn != node)
11719             {
11720               if (CAN_COMPLETE_NORMALLY (node))
11721                 CAN_COMPLETE_NORMALLY (nn) = 1;
11722               POP_LABELED_BLOCK ();
11723             }
11724         }
11725       POP_LOOP ();
11726       return nn;
11727
11728     case EXIT_EXPR:
11729       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11730       return patch_exit_expr (node);
11731
11732     case COND_EXPR:
11733       /* Condition */
11734       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11735       if (TREE_OPERAND (node, 0) == error_mark_node)
11736         return error_mark_node;
11737       /* then-else branches */
11738       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11739       if (TREE_OPERAND (node, 1) == error_mark_node)
11740         return error_mark_node;
11741       TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11742       if (TREE_OPERAND (node, 2) == error_mark_node)
11743         return error_mark_node;
11744       return patch_if_else_statement (node);
11745       break;
11746
11747     case CONDITIONAL_EXPR:
11748       /* Condition */
11749       wfl_op1 = TREE_OPERAND (node, 0);
11750       COMPLETE_CHECK_OP_0 (node);
11751       wfl_op2 = TREE_OPERAND (node, 1);
11752       COMPLETE_CHECK_OP_1 (node);
11753       wfl_op3 = TREE_OPERAND (node, 2);
11754       COMPLETE_CHECK_OP_2 (node);
11755       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11756
11757       /* 3- Expression section */
11758     case COMPOUND_EXPR:
11759       wfl_op2 = TREE_OPERAND (node, 1);
11760       TREE_OPERAND (node, 0) = nn =
11761         java_complete_tree (TREE_OPERAND (node, 0));
11762       if (wfl_op2 == empty_stmt_node)
11763         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11764       else
11765         {
11766           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11767             {
11768               /* An unreachable condition in a do-while statement
11769                  is *not* (technically) an unreachable statement. */
11770               nn = wfl_op2;
11771               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11772                 nn = EXPR_WFL_NODE (nn);
11773               /* NN can be NULL_TREE exactly when UPDATE is, in
11774                  finish_for_loop.  */
11775               if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11776                 {
11777                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11778                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11779                     {
11780                       /* Perhaps this warning should have an
11781                          associated flag.  The code being compiled is
11782                          pedantically correct, but useless.  */
11783                       parse_warning_context (wfl_operator,
11784                                              "Unreachable statement");
11785                     }
11786                   else
11787                     parse_error_context (wfl_operator,
11788                                          "Unreachable statement");
11789                 }
11790             }
11791           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11792           if (TREE_OPERAND (node, 1) == error_mark_node)
11793             return error_mark_node;
11794           /* Even though we might allow the case where the first
11795              operand doesn't return normally, we still should compute
11796              CAN_COMPLETE_NORMALLY correctly.  */
11797           CAN_COMPLETE_NORMALLY (node)
11798             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11799                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11800         }
11801       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11802       break;
11803
11804     case RETURN_EXPR:
11805       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11806       return patch_return (node);
11807
11808     case EXPR_WITH_FILE_LOCATION:
11809       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11810           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11811         {
11812           tree wfl = node;
11813           node = resolve_expression_name (node, NULL);
11814           if (node == error_mark_node)
11815             return node;
11816           /* Keep line number information somewhere were it doesn't
11817              disrupt the completion process. */
11818           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11819             {
11820               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11821               TREE_OPERAND (node, 1) = wfl;
11822             }
11823           CAN_COMPLETE_NORMALLY (node) = 1;
11824         }
11825       else
11826         {
11827           tree body;
11828           int save_lineno = input_line;
11829           input_line = EXPR_WFL_LINENO (node);
11830           body = java_complete_tree (EXPR_WFL_NODE (node));
11831           input_line = save_lineno;
11832           EXPR_WFL_NODE (node) = body;
11833           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11834           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11835           if (body == empty_stmt_node || TREE_CONSTANT (body))
11836             {
11837               /* Makes it easier to constant fold, detect empty bodies. */
11838               return body;
11839             }
11840           if (body == error_mark_node)
11841             {
11842               /* Its important for the evaluation of assignment that
11843                  this mark on the TREE_TYPE is propagated. */
11844               TREE_TYPE (node) = error_mark_node;
11845               return error_mark_node;
11846             }
11847           else
11848             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11849
11850         }
11851       break;
11852
11853     case NEW_ARRAY_EXPR:
11854       /* Patch all the dimensions */
11855       flag = 0;
11856       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11857         {
11858           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11859           tree dim = convert (int_type_node,
11860                               java_complete_tree (TREE_VALUE (cn)));
11861           if (dim == error_mark_node)
11862             {
11863               flag = 1;
11864               continue;
11865             }
11866           else
11867             {
11868               TREE_VALUE (cn) = dim;
11869               /* Setup the location of the current dimension, for
11870                  later error report. */
11871               TREE_PURPOSE (cn) =
11872                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11873               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11874             }
11875         }
11876       /* They complete the array creation expression, if no errors
11877          were found. */
11878       CAN_COMPLETE_NORMALLY (node) = 1;
11879       return (flag ? error_mark_node
11880               : force_evaluation_order (patch_newarray (node)));
11881
11882     case NEW_ANONYMOUS_ARRAY_EXPR:
11883       /* Create the array type if necessary. */
11884       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11885         {
11886           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11887           if (!(type = resolve_type_during_patch (type)))
11888             return error_mark_node;
11889           type = build_array_from_name (type, NULL_TREE,
11890                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11891           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11892         }
11893       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11894                                    ANONYMOUS_ARRAY_INITIALIZER (node));
11895       if (node == error_mark_node)
11896         return error_mark_node;
11897       CAN_COMPLETE_NORMALLY (node) = 1;
11898       return node;
11899
11900     case NEW_CLASS_EXPR:
11901     case CALL_EXPR:
11902       /* Complete function's argument(s) first */
11903       if (complete_function_arguments (node))
11904         return error_mark_node;
11905       else
11906         {
11907           tree decl, wfl = TREE_OPERAND (node, 0);
11908           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11909           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11910                            super_identifier_node);
11911           tree arguments;
11912           int location = EXPR_WFL_LINECOL (node);
11913
11914           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11915                                           from_super, 0, &decl);
11916           if (node == error_mark_node)
11917             return error_mark_node;
11918
11919           if (TREE_CODE (node) == CALL_EXPR
11920               && TREE_OPERAND (node, 1) != NULL_TREE)
11921             arguments = TREE_VALUE (TREE_OPERAND (node, 1));
11922           else
11923             arguments = NULL_TREE;
11924           check_thrown_exceptions (location, decl, arguments);
11925           /* If we call this(...), register signature and positions */
11926           if (in_this)
11927             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11928               tree_cons (wfl, decl,
11929                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
11930           CAN_COMPLETE_NORMALLY (node) = 1;
11931           return force_evaluation_order (node);
11932         }
11933
11934     case MODIFY_EXPR:
11935       /* Save potential wfls */
11936       wfl_op1 = TREE_OPERAND (node, 0);
11937       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11938
11939       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11940           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11941           && DECL_INITIAL (nn) != NULL_TREE)
11942         {
11943           tree value;
11944
11945           value = fold_constant_for_init (nn, nn);
11946
11947           /* When we have a primitype type, or a string and we're not
11948              emitting a class file, we actually don't want to generate
11949              anything for the assignment. */
11950           if (value != NULL_TREE &&
11951               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
11952                (TREE_TYPE (value) == string_ptr_type_node &&
11953                 ! flag_emit_class_files)))
11954             {
11955               /* Prepare node for patch_assignment */
11956               TREE_OPERAND (node, 1) = value;
11957               /* Call patch assignment to verify the assignment */
11958               if (patch_assignment (node, wfl_op1) == error_mark_node)
11959                 return error_mark_node;
11960               /* Set DECL_INITIAL properly (a conversion might have
11961                  been decided by patch_assignment) and return the
11962                  empty statement. */
11963               else
11964                 {
11965                   tree patched = patch_string (TREE_OPERAND (node, 1));
11966                   if (patched)
11967                     DECL_INITIAL (nn) = patched;
11968                   else
11969                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11970                   DECL_FIELD_FINAL_IUD (nn) = 1;
11971                   return empty_stmt_node;
11972                 }
11973             }
11974           if (! flag_emit_class_files)
11975             DECL_INITIAL (nn) = NULL_TREE;
11976         }
11977       wfl_op2 = TREE_OPERAND (node, 1);
11978
11979       if (TREE_OPERAND (node, 0) == error_mark_node)
11980         return error_mark_node;
11981
11982       flag = COMPOUND_ASSIGN_P (wfl_op2);
11983       if (flag)
11984         {
11985           /* This might break when accessing outer field from inner
11986              class. TESTME, FIXME */
11987           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
11988
11989           /* Hand stabilize the lhs on both places */
11990           TREE_OPERAND (node, 0) = lvalue;
11991           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
11992             (flag_emit_class_files ? lvalue : save_expr (lvalue));
11993
11994           /* 15.25.2.a: Left hand is not an array access. FIXME */
11995           /* Now complete the RHS. We write it back later on. */
11996           nn = java_complete_tree (TREE_OPERAND (node, 1));
11997
11998           if ((cn = patch_string (nn)))
11999             nn = cn;
12000
12001           /* The last part of the rewrite for E1 op= E2 is to have
12002              E1 = (T)(E1 op E2), with T being the type of E1. */
12003           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
12004                                                TREE_TYPE (lvalue), nn));
12005
12006           /* If the assignment is compound and has reference type,
12007              then ensure the LHS has type String and nothing else.  */
12008           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
12009               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
12010             parse_error_context (wfl_op2,
12011                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
12012                                  lang_printable_name (TREE_TYPE (lvalue), 0));
12013
12014           /* 15.25.2.b: Left hand is an array access. FIXME */
12015         }
12016
12017       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12018          function to complete this RHS. Note that a NEW_ARRAY_INIT
12019          might have been already fully expanded if created as a result
12020          of processing an anonymous array initializer. We avoid doing
12021          the operation twice by testing whether the node already bears
12022          a type. */
12023       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12024         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12025                                    TREE_OPERAND (node, 1));
12026       /* Otherwise we simply complete the RHS */
12027       else
12028         nn = java_complete_tree (TREE_OPERAND (node, 1));
12029
12030       if (nn == error_mark_node)
12031         return error_mark_node;
12032
12033       /* Write back the RHS as we evaluated it. */
12034       TREE_OPERAND (node, 1) = nn;
12035
12036       /* In case we're handling = with a String as a RHS, we need to
12037          produce a String out of the RHS (it might still be a
12038          STRING_CST or a StringBuffer at this stage */
12039       if ((nn = patch_string (TREE_OPERAND (node, 1))))
12040         TREE_OPERAND (node, 1) = nn;
12041
12042       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12043                                         TREE_OPERAND (node, 1))))
12044         {
12045           /* We return error_mark_node if outer_field_access_fix
12046              detects we write into a final. */
12047           if (nn == error_mark_node)
12048             return error_mark_node;
12049           node = nn;
12050         }
12051       else
12052         {
12053           node = patch_assignment (node, wfl_op1);
12054           if (node == error_mark_node)
12055             return error_mark_node;
12056           /* Reorganize the tree if necessary. */
12057           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12058                        || JSTRING_P (TREE_TYPE (node))))
12059             node = java_refold (node);
12060         }
12061
12062       /* Seek to set DECL_INITIAL to a proper value, since it might have
12063          undergone a conversion in patch_assignment. We do that only when
12064          it's necessary to have DECL_INITIAL properly set. */
12065       nn = TREE_OPERAND (node, 0);
12066       if (TREE_CODE (nn) == VAR_DECL
12067           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12068           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12069           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12070               || TREE_TYPE (nn) == string_ptr_type_node))
12071         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12072
12073       CAN_COMPLETE_NORMALLY (node) = 1;
12074       return node;
12075
12076     case MULT_EXPR:
12077     case PLUS_EXPR:
12078     case MINUS_EXPR:
12079     case LSHIFT_EXPR:
12080     case RSHIFT_EXPR:
12081     case URSHIFT_EXPR:
12082     case BIT_AND_EXPR:
12083     case BIT_XOR_EXPR:
12084     case BIT_IOR_EXPR:
12085     case TRUNC_MOD_EXPR:
12086     case TRUNC_DIV_EXPR:
12087     case RDIV_EXPR:
12088     case TRUTH_ANDIF_EXPR:
12089     case TRUTH_ORIF_EXPR:
12090     case EQ_EXPR:
12091     case NE_EXPR:
12092     case GT_EXPR:
12093     case GE_EXPR:
12094     case LT_EXPR:
12095     case LE_EXPR:
12096       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12097          knows how to handle those cases. */
12098       wfl_op1 = TREE_OPERAND (node, 0);
12099       wfl_op2 = TREE_OPERAND (node, 1);
12100
12101       CAN_COMPLETE_NORMALLY (node) = 1;
12102       /* Don't complete string nodes if dealing with the PLUS operand. */
12103       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12104         {
12105           nn = java_complete_tree (wfl_op1);
12106           if (nn == error_mark_node)
12107             return error_mark_node;
12108
12109           TREE_OPERAND (node, 0) = nn;
12110         }
12111       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12112         {
12113           nn = java_complete_tree (wfl_op2);
12114           if (nn == error_mark_node)
12115             return error_mark_node;
12116
12117           TREE_OPERAND (node, 1) = nn;
12118         }
12119       return patch_binop (node, wfl_op1, wfl_op2);
12120
12121     case INSTANCEOF_EXPR:
12122       wfl_op1 = TREE_OPERAND (node, 0);
12123       COMPLETE_CHECK_OP_0 (node);
12124       if (flag_emit_xref)
12125         {
12126           TREE_TYPE (node) = boolean_type_node;
12127           return node;
12128         }
12129       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12130
12131     case UNARY_PLUS_EXPR:
12132     case NEGATE_EXPR:
12133     case TRUTH_NOT_EXPR:
12134     case BIT_NOT_EXPR:
12135     case PREDECREMENT_EXPR:
12136     case PREINCREMENT_EXPR:
12137     case POSTDECREMENT_EXPR:
12138     case POSTINCREMENT_EXPR:
12139     case CONVERT_EXPR:
12140       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12141          how to handle those cases. */
12142       wfl_op1 = TREE_OPERAND (node, 0);
12143       CAN_COMPLETE_NORMALLY (node) = 1;
12144       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12145       if (TREE_OPERAND (node, 0) == error_mark_node)
12146         return error_mark_node;
12147       node = patch_unaryop (node, wfl_op1);
12148       CAN_COMPLETE_NORMALLY (node) = 1;
12149       break;
12150
12151     case ARRAY_REF:
12152       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12153          how to handle those cases. */
12154       wfl_op1 = TREE_OPERAND (node, 0);
12155       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12156       if (TREE_OPERAND (node, 0) == error_mark_node)
12157         return error_mark_node;
12158       if (!flag_emit_class_files && !flag_emit_xref)
12159         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12160       /* The same applies to wfl_op2 */
12161       wfl_op2 = TREE_OPERAND (node, 1);
12162       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12163       if (TREE_OPERAND (node, 1) == error_mark_node)
12164         return error_mark_node;
12165       if (!flag_emit_class_files && !flag_emit_xref)
12166         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12167       return patch_array_ref (node);
12168
12169     case RECORD_TYPE:
12170       return node;;
12171
12172     case COMPONENT_REF:
12173       /* The first step in the re-write of qualified name handling.  FIXME.
12174          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12175       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12176       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12177         {
12178           tree name = TREE_OPERAND (node, 1);
12179           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12180           if (field == NULL_TREE)
12181             {
12182               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12183               return error_mark_node;
12184             }
12185           if (! FIELD_STATIC (field))
12186             {
12187               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12188               return error_mark_node;
12189             }
12190           return field;
12191         }
12192       else
12193         abort ();
12194       break;
12195
12196     case THIS_EXPR:
12197       /* Can't use THIS in a static environment */
12198       if (!current_this)
12199         {
12200           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12201           parse_error_context (wfl_operator,
12202                                "Keyword `this' used outside allowed context");
12203           TREE_TYPE (node) = error_mark_node;
12204           return error_mark_node;
12205         }
12206       if (ctxp->explicit_constructor_p)
12207         {
12208           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12209           parse_error_context
12210             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12211           TREE_TYPE (node) = error_mark_node;
12212           return error_mark_node;
12213         }
12214       return current_this;
12215
12216     case CLASS_LITERAL:
12217       CAN_COMPLETE_NORMALLY (node) = 1;
12218       node = patch_incomplete_class_ref (node);
12219       if (node == error_mark_node)
12220         return error_mark_node;
12221       break;
12222
12223     default:
12224       CAN_COMPLETE_NORMALLY (node) = 1;
12225       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12226          and it's time to turn it into the appropriate String object */
12227       if ((nn = patch_string (node)))
12228         node = nn;
12229       else
12230         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12231     }
12232   return node;
12233 }
12234
12235 /* Complete function call's argument. Return a nonzero value is an
12236    error was found.  */
12237
12238 static int
12239 complete_function_arguments (tree node)
12240 {
12241   int flag = 0;
12242   tree cn;
12243
12244   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12245   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12246     {
12247       tree wfl = TREE_VALUE (cn), parm, temp;
12248       parm = java_complete_tree (wfl);
12249
12250       if (parm == error_mark_node)
12251         {
12252           flag = 1;
12253           continue;
12254         }
12255       /* If have a string literal that we haven't transformed yet or a
12256          crafted string buffer, as a result of use of the the String
12257          `+' operator. Build `parm.toString()' and expand it. */
12258       if ((temp = patch_string (parm)))
12259         parm = temp;
12260
12261       TREE_VALUE (cn) = parm;
12262     }
12263   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12264   return flag;
12265 }
12266
12267 /* Sometimes (for loops and variable initialized during their
12268    declaration), we want to wrap a statement around a WFL and turn it
12269    debugable.  */
12270
12271 static tree
12272 build_debugable_stmt (int location, tree stmt)
12273 {
12274   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12275     {
12276       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12277       EXPR_WFL_LINECOL (stmt) = location;
12278     }
12279   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12280   return stmt;
12281 }
12282
12283 static tree
12284 build_expr_block (tree body, tree decls)
12285
12286 {
12287   tree node = make_node (BLOCK);
12288   BLOCK_EXPR_DECLS (node) = decls;
12289   BLOCK_EXPR_BODY (node) = body;
12290   if (body)
12291     TREE_TYPE (node) = TREE_TYPE (body);
12292   TREE_SIDE_EFFECTS (node) = 1;
12293   return node;
12294 }
12295
12296 /* Create a new function block and link it appropriately to current
12297    function block chain */
12298
12299 static tree
12300 enter_block (void)
12301 {
12302   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12303
12304   /* Link block B supercontext to the previous block. The current
12305      function DECL is used as supercontext when enter_a_block is called
12306      for the first time for a given function. The current function body
12307      (DECL_FUNCTION_BODY) is set to be block B.  */
12308
12309   tree fndecl = current_function_decl;
12310
12311   if (!fndecl) {
12312     BLOCK_SUPERCONTEXT (b) = current_static_block;
12313     current_static_block = b;
12314   }
12315
12316   else if (!DECL_FUNCTION_BODY (fndecl))
12317     {
12318       BLOCK_SUPERCONTEXT (b) = fndecl;
12319       DECL_FUNCTION_BODY (fndecl) = b;
12320     }
12321   else
12322     {
12323       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12324       DECL_FUNCTION_BODY (fndecl) = b;
12325     }
12326   return b;
12327 }
12328
12329 /* Exit a block by changing the current function body
12330    (DECL_FUNCTION_BODY) to the current block super context, only if
12331    the block being exited isn't the method's top level one.  */
12332
12333 static tree
12334 exit_block (void)
12335 {
12336   tree b;
12337   if (current_function_decl)
12338     {
12339       b = DECL_FUNCTION_BODY (current_function_decl);
12340       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12341         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12342     }
12343   else
12344     {
12345       b = current_static_block;
12346
12347       if (BLOCK_SUPERCONTEXT (b))
12348         current_static_block = BLOCK_SUPERCONTEXT (b);
12349     }
12350   return b;
12351 }
12352
12353 /* Lookup for NAME in the nested function's blocks, all the way up to
12354    the current toplevel one. It complies with Java's local variable
12355    scoping rules.  */
12356
12357 static tree
12358 lookup_name_in_blocks (tree name)
12359 {
12360   tree b = GET_CURRENT_BLOCK (current_function_decl);
12361
12362   while (b != current_function_decl)
12363     {
12364       tree current;
12365
12366       /* Paranoid sanity check. To be removed */
12367       if (TREE_CODE (b) != BLOCK)
12368         abort ();
12369
12370       for (current = BLOCK_EXPR_DECLS (b); current;
12371            current = TREE_CHAIN (current))
12372         if (DECL_NAME (current) == name)
12373           return current;
12374       b = BLOCK_SUPERCONTEXT (b);
12375     }
12376   return NULL_TREE;
12377 }
12378
12379 static void
12380 maybe_absorb_scoping_blocks (void)
12381 {
12382   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12383     {
12384       tree b = exit_block ();
12385       java_method_add_stmt (current_function_decl, b);
12386       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12387     }
12388 }
12389
12390 \f
12391 /* This section of the source is reserved to build_* functions that
12392    are building incomplete tree nodes and the patch_* functions that
12393    are completing them.  */
12394
12395 /* Wrap a non WFL node around a WFL.  */
12396
12397 static tree
12398 build_wfl_wrap (tree node, int location)
12399 {
12400   tree wfl, node_to_insert = node;
12401
12402   /* We want to process THIS . xxx symbolically, to keep it consistent
12403      with the way we're processing SUPER. A THIS from a primary as a
12404      different form than a SUPER. Turn THIS into something symbolic */
12405   if (TREE_CODE (node) == THIS_EXPR)
12406     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12407   else
12408     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12409
12410   EXPR_WFL_LINECOL (wfl) = location;
12411   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12412   return wfl;
12413 }
12414
12415 /* Build a super() constructor invocation. Returns empty_stmt_node if
12416    we're currently dealing with the class java.lang.Object. */
12417
12418 static tree
12419 build_super_invocation (tree mdecl)
12420 {
12421   if (DECL_CONTEXT (mdecl) == object_type_node)
12422     return empty_stmt_node;
12423   else
12424     {
12425       tree super_wfl = build_wfl_node (super_identifier_node);
12426       tree a = NULL_TREE, t;
12427       /* If we're dealing with an anonymous class, pass the arguments
12428          of the crafted constructor along. */
12429       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12430         {
12431           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12432           for (; t != end_params_node; t = TREE_CHAIN (t))
12433             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12434         }
12435       return build_method_invocation (super_wfl, a);
12436     }
12437 }
12438
12439 /* Build a SUPER/THIS qualified method invocation.  */
12440
12441 static tree
12442 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12443                                        int lloc, int rloc)
12444 {
12445   tree invok;
12446   tree wfl =
12447     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12448   EXPR_WFL_LINECOL (wfl) = lloc;
12449   invok = build_method_invocation (name, args);
12450   return make_qualified_primary (wfl, invok, rloc);
12451 }
12452
12453 /* Build an incomplete CALL_EXPR node. */
12454
12455 static tree
12456 build_method_invocation (tree name, tree args)
12457 {
12458   tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12459   TREE_SIDE_EFFECTS (call) = 1;
12460   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12461   return call;
12462 }
12463
12464 /* Build an incomplete new xxx(...) node. */
12465
12466 static tree
12467 build_new_invocation (tree name, tree args)
12468 {
12469   tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12470   TREE_SIDE_EFFECTS (call) = 1;
12471   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12472   return call;
12473 }
12474
12475 /* Build an incomplete assignment expression. */
12476
12477 static tree
12478 build_assignment (int op, int op_location, tree lhs, tree rhs)
12479 {
12480   tree assignment;
12481   /* Build the corresponding binop if we deal with a Compound
12482      Assignment operator. Mark the binop sub-tree as part of a
12483      Compound Assignment expression */
12484   if (op != ASSIGN_TK)
12485     {
12486       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12487       COMPOUND_ASSIGN_P (rhs) = 1;
12488     }
12489   assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12490   TREE_SIDE_EFFECTS (assignment) = 1;
12491   EXPR_WFL_LINECOL (assignment) = op_location;
12492   return assignment;
12493 }
12494
12495 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12496    the buffer.  This is used only for string conversion.  */
12497 static char *
12498 string_convert_int_cst (tree node)
12499 {
12500   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12501   static char buffer[21];
12502
12503   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12504   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12505   char *p = buffer + sizeof (buffer);
12506   int neg = 0;
12507
12508   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12509                                   << (HOST_BITS_PER_WIDE_INT - 1));
12510
12511   *--p = '\0';
12512
12513   /* If negative, note the fact and negate the value.  */
12514   if ((hi & hibit))
12515     {
12516       lo = ~lo;
12517       hi = ~hi;
12518       if (++lo == 0)
12519         ++hi;
12520       neg = 1;
12521     }
12522
12523   /* Divide by 10 until there are no bits left.  */
12524   do
12525     {
12526       unsigned HOST_WIDE_INT acc = 0;
12527       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12528       unsigned int i;
12529
12530       /* Use long division to compute the result and the remainder.  */
12531       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12532         {
12533           /* Shift a bit into accumulator.  */
12534           acc <<= 1;
12535           if ((hi & hibit))
12536             acc |= 1;
12537
12538           /* Shift the value.  */
12539           hi <<= 1;
12540           if ((lo & hibit))
12541             hi |= 1;
12542           lo <<= 1;
12543
12544           /* Shift the correct bit into the result.  */
12545           outhi <<= 1;
12546           if ((outlo & hibit))
12547             outhi |= 1;
12548           outlo <<= 1;
12549           if (acc >= 10)
12550             {
12551               acc -= 10;
12552               outlo |= 1;
12553             }
12554         }
12555
12556       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12557       *--p = '\060' + acc;
12558
12559       hi = outhi;
12560       lo = outlo;
12561     }
12562   while (hi || lo);
12563
12564   if (neg)
12565     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12566
12567   return p;
12568 }
12569
12570 /* Print an INTEGER_CST node in a static buffer, and return the
12571    buffer.  This is used only for error handling.  */
12572 char *
12573 print_int_node (tree node)
12574 {
12575   static char buffer [80];
12576   if (TREE_CONSTANT_OVERFLOW (node))
12577     sprintf (buffer, "<overflow>");
12578
12579   if (TREE_INT_CST_HIGH (node) == 0)
12580     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12581              TREE_INT_CST_LOW (node));
12582   else if (TREE_INT_CST_HIGH (node) == -1
12583            && TREE_INT_CST_LOW (node) != 0)
12584     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12585              -TREE_INT_CST_LOW (node));
12586   else
12587     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12588              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12589
12590   return buffer;
12591 }
12592
12593 \f
12594 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12595    context.  */
12596
12597 /* 15.25 Assignment operators. */
12598
12599 static tree
12600 patch_assignment (tree node, tree wfl_op1)
12601 {
12602   tree rhs = TREE_OPERAND (node, 1);
12603   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12604   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12605   int error_found = 0;
12606   int lvalue_from_array = 0;
12607   int is_return = 0;
12608
12609   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12610
12611   /* Lhs can be a named variable */
12612   if (JDECL_P (lvalue))
12613     {
12614       lhs_type = TREE_TYPE (lvalue);
12615     }
12616   /* Or Lhs can be an array access. */
12617   else if (TREE_CODE (lvalue) == ARRAY_REF)
12618     {
12619       lhs_type = TREE_TYPE (lvalue);
12620       lvalue_from_array = 1;
12621     }
12622   /* Or a field access */
12623   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12624     lhs_type = TREE_TYPE (lvalue);
12625   /* Or a function return slot */
12626   else if (TREE_CODE (lvalue) == RESULT_DECL)
12627     {
12628       /* If the return type is an integral type, then we create the
12629          RESULT_DECL with a promoted type, but we need to do these
12630          checks against the unpromoted type to ensure type safety.  So
12631          here we look at the real type, not the type of the decl we
12632          are modifying.  */
12633       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12634       is_return = 1;
12635     }
12636   /* Otherwise, we might want to try to write into an optimized static
12637      final, this is an of a different nature, reported further on. */
12638   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12639            && resolve_expression_name (wfl_op1, &llvalue))
12640     {
12641       lhs_type = TREE_TYPE (lvalue);
12642     }
12643   else
12644     {
12645       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12646       error_found = 1;
12647     }
12648
12649   rhs_type = TREE_TYPE (rhs);
12650
12651   /* 5.1 Try the assignment conversion for builtin type. */
12652   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12653
12654   /* 5.2 If it failed, try a reference conversion */
12655   if (!new_rhs && (new_rhs = try_reference_assignconv (lhs_type, rhs)))
12656     lhs_type = promote_type (rhs_type);
12657
12658   /* 15.25.2 If we have a compound assignment, convert RHS into the
12659      type of the LHS */
12660   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12661     new_rhs = convert (lhs_type, rhs);
12662
12663   /* Explicit cast required. This is an error */
12664   if (!new_rhs)
12665     {
12666       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12667       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12668       tree wfl;
12669       char operation [32];      /* Max size known */
12670
12671       /* If the assignment is part of a declaration, we use the WFL of
12672          the declared variable to point out the error and call it a
12673          declaration problem. If the assignment is a genuine =
12674          operator, we call is a operator `=' problem, otherwise we
12675          call it an assignment problem. In both of these last cases,
12676          we use the WFL of the operator to indicate the error. */
12677
12678       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12679         {
12680           wfl = wfl_op1;
12681           strcpy (operation, "declaration");
12682         }
12683       else
12684         {
12685           wfl = wfl_operator;
12686           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12687             strcpy (operation, "assignment");
12688           else if (is_return)
12689             strcpy (operation, "`return'");
12690           else
12691             strcpy (operation, "`='");
12692         }
12693
12694       if (!valid_cast_to_p (rhs_type, lhs_type))
12695         parse_error_context
12696           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12697            operation, t1, t2);
12698       else
12699         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12700                              operation, t1, t2);
12701       free (t1); free (t2);
12702       error_found = 1;
12703     }
12704
12705   if (error_found)
12706     return error_mark_node;
12707
12708   /* If we're processing a `return' statement, promote the actual type
12709      to the promoted type.  */
12710   if (is_return)
12711     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12712
12713   /* 10.10: Array Store Exception runtime check */
12714   if (!flag_emit_class_files
12715       && !flag_emit_xref
12716       && lvalue_from_array
12717       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12718     {
12719       tree array, store_check, base, index_expr;
12720
12721       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12722       new_rhs = save_expr (new_rhs);
12723
12724       /* Get the INDIRECT_REF. */
12725       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12726       /* Get the array pointer expr. */
12727       array = TREE_OPERAND (array, 0);
12728       store_check = build_java_arraystore_check (array, new_rhs);
12729
12730       index_expr = TREE_OPERAND (lvalue, 1);
12731
12732       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12733         {
12734           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12735              happen before the store check, so prepare to insert the store
12736              check within the second operand of the existing COMPOUND_EXPR. */
12737           base = index_expr;
12738         }
12739       else
12740         base = lvalue;
12741
12742       index_expr = TREE_OPERAND (base, 1);
12743       TREE_OPERAND (base, 1) = build (COMPOUND_EXPR, TREE_TYPE (index_expr),
12744                                       store_check, index_expr);
12745     }
12746
12747   /* Final locals can be used as case values in switch
12748      statement. Prepare them for this eventuality. */
12749   if (TREE_CODE (lvalue) == VAR_DECL
12750       && DECL_FINAL (lvalue)
12751       && TREE_CONSTANT (new_rhs)
12752       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12753       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12754       )
12755     {
12756       TREE_CONSTANT (lvalue) = 1;
12757       DECL_INITIAL (lvalue) = new_rhs;
12758     }
12759
12760   /* Copy the rhs if it's a reference.  */
12761   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12762     {
12763       switch (TREE_CODE (new_rhs))
12764         {
12765         case ARRAY_REF:
12766         case INDIRECT_REF:
12767         case COMPONENT_REF:
12768           /* Transform a = foo.bar
12769              into a = { int tmp; tmp = foo.bar; tmp; ).
12770              We need to ensure that if a read from memory fails
12771              because of a NullPointerException, a destination variable
12772              will remain unchanged.  An explicit temporary does what
12773              we need.
12774
12775              If flag_check_references is set, this is unnecessary
12776              because we'll check each reference before doing any
12777              reads.  If optimize is not set the result will never be
12778              written to a stack slot that contains the LHS.  */
12779           {
12780             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12781                                    TREE_TYPE (new_rhs));
12782             tree block = make_node (BLOCK);
12783             tree assignment
12784               = build (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12785             DECL_CONTEXT (tmp) = current_function_decl;
12786             TREE_TYPE (block) = TREE_TYPE (new_rhs);
12787             BLOCK_VARS (block) = tmp;
12788             BLOCK_EXPR_BODY (block)
12789               = build (COMPOUND_EXPR, TREE_TYPE (new_rhs), assignment, tmp);
12790             TREE_SIDE_EFFECTS (block) = 1;
12791             new_rhs = block;
12792           }
12793           break;
12794         default:
12795           break;
12796         }
12797     }
12798
12799   TREE_OPERAND (node, 0) = lvalue;
12800   TREE_OPERAND (node, 1) = new_rhs;
12801   TREE_TYPE (node) = lhs_type;
12802   return node;
12803 }
12804
12805 /* Check that type SOURCE can be cast into type DEST. If the cast
12806    can't occur at all, return NULL; otherwise, return a possibly
12807    modified rhs.  */
12808
12809 static tree
12810 try_reference_assignconv (tree lhs_type, tree rhs)
12811 {
12812   tree new_rhs = NULL_TREE;
12813   tree rhs_type = TREE_TYPE (rhs);
12814
12815   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12816     {
12817       /* `null' may be assigned to any reference type */
12818       if (rhs == null_pointer_node)
12819         new_rhs = null_pointer_node;
12820       /* Try the reference assignment conversion */
12821       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12822         new_rhs = rhs;
12823       /* This is a magic assignment that we process differently */
12824       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12825         new_rhs = rhs;
12826     }
12827   return new_rhs;
12828 }
12829
12830 /* Check that RHS can be converted into LHS_TYPE by the assignment
12831    conversion (5.2), for the cases of RHS being a builtin type. Return
12832    NULL_TREE if the conversion fails or if because RHS isn't of a
12833    builtin type. Return a converted RHS if the conversion is possible.  */
12834
12835 static tree
12836 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12837 {
12838   tree new_rhs = NULL_TREE;
12839   tree rhs_type = TREE_TYPE (rhs);
12840
12841   /* Handle boolean specially.  */
12842   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12843       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12844     {
12845       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12846           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12847         new_rhs = rhs;
12848     }
12849
12850   /* 5.1.1 Try Identity Conversion,
12851      5.1.2 Try Widening Primitive Conversion */
12852   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12853     new_rhs = convert (lhs_type, rhs);
12854
12855   /* Try a narrowing primitive conversion (5.1.3):
12856        - expression is a constant expression of type byte, short, char,
12857          or int, AND
12858        - variable is byte, short or char AND
12859        - The value of the expression is representable in the type of the
12860          variable */
12861   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12862             || rhs_type == char_type_node || rhs_type == int_type_node)
12863             && TREE_CONSTANT (rhs)
12864            && (lhs_type == byte_type_node || lhs_type == char_type_node
12865                || lhs_type == short_type_node))
12866     {
12867       if (int_fits_type_p (rhs, lhs_type))
12868         new_rhs = convert (lhs_type, rhs);
12869       else if (wfl_op1)         /* Might be called with a NULL */
12870         parse_warning_context
12871           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12872            print_int_node (rhs), lang_printable_name (lhs_type, 0));
12873       /* Reported a warning that will turn into an error further
12874          down, so we don't return */
12875     }
12876
12877   return new_rhs;
12878 }
12879
12880 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12881    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12882    0 is the conversion test fails.  This implements parts the method
12883    invocation conversion (5.3).  */
12884
12885 static int
12886 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
12887 {
12888   /* 5.1.1: This is the identity conversion part. */
12889   if (lhs_type == rhs_type)
12890     return 1;
12891
12892   /* Reject non primitive types and boolean conversions.  */
12893   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12894     return 0;
12895
12896   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12897      than a char can't be converted into a char. Short can't too, but
12898      the < test below takes care of that */
12899   if (lhs_type == char_type_node && rhs_type == byte_type_node)
12900     return 0;
12901
12902   /* Accept all promoted type here. Note, we can't use <= in the test
12903      below, because we still need to bounce out assignments of short
12904      to char and the likes */
12905   if (lhs_type == int_type_node
12906       && (rhs_type == promoted_byte_type_node
12907           || rhs_type == promoted_short_type_node
12908           || rhs_type == promoted_char_type_node
12909           || rhs_type == promoted_boolean_type_node))
12910     return 1;
12911
12912   /* From here, an integral is widened if its precision is smaller
12913      than the precision of the LHS or if the LHS is a floating point
12914      type, or the RHS is a float and the RHS a double. */
12915   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12916        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12917       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12918       || (rhs_type == float_type_node && lhs_type == double_type_node))
12919     return 1;
12920
12921   return 0;
12922 }
12923
12924 /* Check that something of SOURCE type can be assigned or cast to
12925    something of DEST type at runtime. Return 1 if the operation is
12926    valid, 0 otherwise. If CAST is set to 1, we're treating the case
12927    were SOURCE is cast into DEST, which borrows a lot of the
12928    assignment check. */
12929
12930 static int
12931 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
12932 {
12933   /* SOURCE or DEST might be null if not from a declared entity. */
12934   if (!source || !dest)
12935     return 0;
12936   if (JNULLP_TYPE_P (source))
12937     return 1;
12938   if (TREE_CODE (source) == POINTER_TYPE)
12939     source = TREE_TYPE (source);
12940   if (TREE_CODE (dest) == POINTER_TYPE)
12941     dest = TREE_TYPE (dest);
12942
12943   /* If source and dest are being compiled from bytecode, they may need to
12944      be loaded. */
12945   if (CLASS_P (source) && !CLASS_LOADED_P (source))
12946     {
12947       load_class (source, 1);
12948       safe_layout_class (source);
12949     }
12950   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
12951     {
12952       load_class (dest, 1);
12953       safe_layout_class (dest);
12954     }
12955
12956   /* Case where SOURCE is a class type */
12957   if (TYPE_CLASS_P (source))
12958     {
12959       if (TYPE_CLASS_P (dest))
12960         return  (source == dest
12961                  || inherits_from_p (source, dest)
12962                  || (cast && inherits_from_p (dest, source)));
12963       if (TYPE_INTERFACE_P (dest))
12964         {
12965           /* If doing a cast and SOURCE is final, the operation is
12966              always correct a compile time (because even if SOURCE
12967              does not implement DEST, a subclass of SOURCE might). */
12968           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12969             return 1;
12970           /* Otherwise, SOURCE must implement DEST */
12971           return interface_of_p (dest, source);
12972         }
12973       /* DEST is an array, cast permitted if SOURCE is of Object type */
12974       return (cast && source == object_type_node ? 1 : 0);
12975     }
12976   if (TYPE_INTERFACE_P (source))
12977     {
12978       if (TYPE_CLASS_P (dest))
12979         {
12980           /* If not casting, DEST must be the Object type */
12981           if (!cast)
12982             return dest == object_type_node;
12983           /* We're doing a cast. The cast is always valid is class
12984              DEST is not final, otherwise, DEST must implement SOURCE */
12985           else if (!CLASS_FINAL (TYPE_NAME (dest)))
12986             return 1;
12987           else
12988             return interface_of_p (source, dest);
12989         }
12990       if (TYPE_INTERFACE_P (dest))
12991         {
12992           /* If doing a cast, then if SOURCE and DEST contain method
12993              with the same signature but different return type, then
12994              this is a (compile time) error */
12995           if (cast)
12996             {
12997               tree method_source, method_dest;
12998               tree source_type;
12999               tree source_sig;
13000               tree source_name;
13001               for (method_source = TYPE_METHODS (source); method_source;
13002                    method_source = TREE_CHAIN (method_source))
13003                 {
13004                   source_sig =
13005                     build_java_argument_signature (TREE_TYPE (method_source));
13006                   source_type = TREE_TYPE (TREE_TYPE (method_source));
13007                   source_name = DECL_NAME (method_source);
13008                   for (method_dest = TYPE_METHODS (dest);
13009                        method_dest; method_dest = TREE_CHAIN (method_dest))
13010                     if (source_sig ==
13011                         build_java_argument_signature (TREE_TYPE (method_dest))
13012                         && source_name == DECL_NAME (method_dest)
13013                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
13014                       return 0;
13015                 }
13016               return 1;
13017             }
13018           else
13019             return source == dest || interface_of_p (dest, source);
13020         }
13021       else
13022         {
13023           /* Array */
13024           return (cast
13025                   && (DECL_NAME (TYPE_NAME (source))
13026                       == java_lang_cloneable_identifier_node
13027                       || (DECL_NAME (TYPE_NAME (source))
13028                           == java_io_serializable_identifier_node)));
13029         }
13030     }
13031   if (TYPE_ARRAY_P (source))
13032     {
13033       if (TYPE_CLASS_P (dest))
13034         return dest == object_type_node;
13035       /* Can't cast an array to an interface unless the interface is
13036          java.lang.Cloneable or java.io.Serializable.  */
13037       if (TYPE_INTERFACE_P (dest))
13038         return (DECL_NAME (TYPE_NAME (dest))
13039                 == java_lang_cloneable_identifier_node
13040                 || (DECL_NAME (TYPE_NAME (dest))
13041                     == java_io_serializable_identifier_node));
13042       else                      /* Arrays */
13043         {
13044           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13045           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13046
13047           /* In case of severe errors, they turn out null */
13048           if (!dest_element_type || !source_element_type)
13049             return 0;
13050           if (source_element_type == dest_element_type)
13051             return 1;
13052           return valid_ref_assignconv_cast_p (source_element_type,
13053                                               dest_element_type, cast);
13054         }
13055       return 0;
13056     }
13057   return 0;
13058 }
13059
13060 static int
13061 valid_cast_to_p (tree source, tree dest)
13062 {
13063   if (TREE_CODE (source) == POINTER_TYPE)
13064     source = TREE_TYPE (source);
13065   if (TREE_CODE (dest) == POINTER_TYPE)
13066     dest = TREE_TYPE (dest);
13067
13068   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13069     return valid_ref_assignconv_cast_p (source, dest, 1);
13070
13071   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13072     return 1;
13073
13074   else if (TREE_CODE (source) == BOOLEAN_TYPE
13075            && TREE_CODE (dest) == BOOLEAN_TYPE)
13076     return 1;
13077
13078   return 0;
13079 }
13080
13081 static tree
13082 do_unary_numeric_promotion (tree arg)
13083 {
13084   tree type = TREE_TYPE (arg);
13085   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13086       || TREE_CODE (type) == CHAR_TYPE)
13087     arg = convert (int_type_node, arg);
13088   return arg;
13089 }
13090
13091 /* Return a nonzero value if SOURCE can be converted into DEST using
13092    the method invocation conversion rule (5.3).  */
13093 static int
13094 valid_method_invocation_conversion_p (tree dest, tree source)
13095 {
13096   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13097            && valid_builtin_assignconv_identity_widening_p (dest, source))
13098           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13099               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13100               && valid_ref_assignconv_cast_p (source, dest, 0)));
13101 }
13102
13103 /* Build an incomplete binop expression. */
13104
13105 static tree
13106 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13107 {
13108   tree binop = build (op, NULL_TREE, op1, op2);
13109   TREE_SIDE_EFFECTS (binop) = 1;
13110   /* Store the location of the operator, for better error report. The
13111      string of the operator will be rebuild based on the OP value. */
13112   EXPR_WFL_LINECOL (binop) = op_location;
13113   return binop;
13114 }
13115
13116 /* Build the string of the operator retained by NODE. If NODE is part
13117    of a compound expression, add an '=' at the end of the string. This
13118    function is called when an error needs to be reported on an
13119    operator. The string is returned as a pointer to a static character
13120    buffer. */
13121
13122 static char *
13123 operator_string (tree node)
13124 {
13125 #define BUILD_OPERATOR_STRING(S)                                        \
13126   {                                                                     \
13127     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13128     return buffer;                                                      \
13129   }
13130
13131   static char buffer [10];
13132   switch (TREE_CODE (node))
13133     {
13134     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13135     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13136     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13137     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13138     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13139     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13140     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13141     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13142     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13143     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13144     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13145     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13146     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13147     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13148     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13149     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13150     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13151     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13152     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13153     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13154     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13155     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13156     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13157     case PREINCREMENT_EXPR:     /* Fall through */
13158     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13159     case PREDECREMENT_EXPR:     /* Fall through */
13160     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13161     default:
13162       internal_error ("unregistered operator %s",
13163                       tree_code_name [TREE_CODE (node)]);
13164     }
13165   return NULL;
13166 #undef BUILD_OPERATOR_STRING
13167 }
13168
13169 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13170
13171 static int
13172 java_decl_equiv (tree var_acc1, tree var_acc2)
13173 {
13174   if (JDECL_P (var_acc1))
13175     return (var_acc1 == var_acc2);
13176
13177   return (TREE_CODE (var_acc1) == COMPONENT_REF
13178           && TREE_CODE (var_acc2) == COMPONENT_REF
13179           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13180              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13181           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13182 }
13183
13184 /* Return a nonzero value if CODE is one of the operators that can be
13185    used in conjunction with the `=' operator in a compound assignment.  */
13186
13187 static int
13188 binop_compound_p (enum tree_code code)
13189 {
13190   int i;
13191   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13192     if (binop_lookup [i] == code)
13193       break;
13194
13195   return i < BINOP_COMPOUND_CANDIDATES;
13196 }
13197
13198 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13199
13200 static tree
13201 java_refold (tree t)
13202 {
13203   tree c, b, ns, decl;
13204
13205   if (TREE_CODE (t) != MODIFY_EXPR)
13206     return t;
13207
13208   c = TREE_OPERAND (t, 1);
13209   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13210          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13211          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13212     return t;
13213
13214   /* Now the left branch of the binary operator. */
13215   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13216   if (! (b && TREE_CODE (b) == NOP_EXPR
13217          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13218     return t;
13219
13220   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13221   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13222          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13223     return t;
13224
13225   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13226   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13227       /* It's got to be the an equivalent decl */
13228       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13229     {
13230       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13231       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13232       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13233       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13234       /* Change the right part of the BINOP_EXPR */
13235       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13236     }
13237
13238   return t;
13239 }
13240
13241 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13242    errors but we modify NODE so that it contains the type computed
13243    according to the expression, when it's fixed. Otherwise, we write
13244    error_mark_node as the type. It allows us to further the analysis
13245    of remaining nodes and detects more errors in certain cases.  */
13246
13247 static tree
13248 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13249 {
13250   tree op1 = TREE_OPERAND (node, 0);
13251   tree op2 = TREE_OPERAND (node, 1);
13252   tree op1_type = TREE_TYPE (op1);
13253   tree op2_type = TREE_TYPE (op2);
13254   tree prom_type = NULL_TREE, cn;
13255   enum tree_code code = TREE_CODE (node);
13256
13257   /* If 1, tell the routine that we have to return error_mark_node
13258      after checking for the initialization of the RHS */
13259   int error_found = 0;
13260
13261   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13262
13263   /* If either op<n>_type are NULL, this might be early signs of an
13264      error situation, unless it's too early to tell (in case we're
13265      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13266      correctly so the error can be later on reported accurately. */
13267   if (! (code == PLUS_EXPR || code == NE_EXPR
13268          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13269     {
13270       tree n;
13271       if (! op1_type)
13272         {
13273           n = java_complete_tree (op1);
13274           op1_type = TREE_TYPE (n);
13275         }
13276       if (! op2_type)
13277         {
13278           n = java_complete_tree (op2);
13279           op2_type = TREE_TYPE (n);
13280         }
13281     }
13282
13283   switch (code)
13284     {
13285     /* 15.16 Multiplicative operators */
13286     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13287     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13288     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13289     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13290       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13291         {
13292           if (!JNUMERIC_TYPE_P (op1_type))
13293             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13294           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13295             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13296           TREE_TYPE (node) = error_mark_node;
13297           error_found = 1;
13298           break;
13299         }
13300       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13301
13302       /* Detect integral division by zero */
13303       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13304           && TREE_CODE (prom_type) == INTEGER_TYPE
13305           && (op2 == integer_zero_node || op2 == long_zero_node ||
13306               (TREE_CODE (op2) == INTEGER_CST &&
13307                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13308         {
13309           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13310           TREE_CONSTANT (node) = 0;
13311         }
13312
13313       /* Change the division operator if necessary */
13314       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13315         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13316
13317       /* Before divisions as is disappear, try to simplify and bail if
13318          applicable, otherwise we won't perform even simple
13319          simplifications like (1-1)/3. We can't do that with floating
13320          point number, folds can't handle them at this stage. */
13321       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13322           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13323         {
13324           TREE_TYPE (node) = prom_type;
13325           node = fold (node);
13326           if (TREE_CODE (node) != code)
13327             return node;
13328         }
13329
13330       if (TREE_CODE (prom_type) == INTEGER_TYPE
13331           && flag_use_divide_subroutine
13332           && ! flag_emit_class_files
13333           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13334         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13335
13336       /* This one is more complicated. FLOATs are processed by a
13337          function call to soft_fmod. Duplicate the value of the
13338          COMPOUND_ASSIGN_P flag. */
13339       if (code == TRUNC_MOD_EXPR)
13340         {
13341           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13342           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13343           TREE_SIDE_EFFECTS (mod)
13344             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13345           return mod;
13346         }
13347       break;
13348
13349     /* 15.17 Additive Operators */
13350     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13351
13352       /* Operation is valid if either one argument is a string
13353          constant, a String object or a StringBuffer crafted for the
13354          purpose of the a previous usage of the String concatenation
13355          operator */
13356
13357       if (TREE_CODE (op1) == STRING_CST
13358           || TREE_CODE (op2) == STRING_CST
13359           || JSTRING_TYPE_P (op1_type)
13360           || JSTRING_TYPE_P (op2_type)
13361           || IS_CRAFTED_STRING_BUFFER_P (op1)
13362           || IS_CRAFTED_STRING_BUFFER_P (op2))
13363         return build_string_concatenation (op1, op2);
13364
13365     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13366                                    Numeric Types */
13367       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13368         {
13369           if (!JNUMERIC_TYPE_P (op1_type))
13370             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13371           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13372             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13373           TREE_TYPE (node) = error_mark_node;
13374           error_found = 1;
13375           break;
13376         }
13377       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13378       break;
13379
13380     /* 15.18 Shift Operators */
13381     case LSHIFT_EXPR:
13382     case RSHIFT_EXPR:
13383     case URSHIFT_EXPR:
13384       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13385         {
13386           if (!JINTEGRAL_TYPE_P (op1_type))
13387             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13388           else
13389             {
13390               if (JNUMERIC_TYPE_P (op2_type))
13391                 parse_error_context (wfl_operator,
13392                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13393                                      operator_string (node),
13394                                      lang_printable_name (op2_type, 0));
13395               else
13396                 parse_error_context (wfl_operator,
13397                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13398                                      operator_string (node),
13399                                      lang_printable_name (op2_type, 0));
13400             }
13401           TREE_TYPE (node) = error_mark_node;
13402           error_found = 1;
13403           break;
13404         }
13405
13406       /* Unary numeric promotion (5.6.1) is performed on each operand
13407          separately */
13408       op1 = do_unary_numeric_promotion (op1);
13409       op2 = do_unary_numeric_promotion (op2);
13410
13411       /* If the right hand side is of type `long', first cast it to
13412          `int'.  */
13413       if (TREE_TYPE (op2) == long_type_node)
13414         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13415
13416       /* The type of the shift expression is the type of the promoted
13417          type of the left-hand operand */
13418       prom_type = TREE_TYPE (op1);
13419
13420       /* Shift int only up to 0x1f and long up to 0x3f */
13421       if (prom_type == int_type_node)
13422         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13423                            build_int_2 (0x1f, 0)));
13424       else
13425         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13426                            build_int_2 (0x3f, 0)));
13427
13428       /* The >>> operator is a >> operating on unsigned quantities */
13429       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13430         {
13431           tree to_return;
13432           tree utype = java_unsigned_type (prom_type);
13433           op1 = convert (utype, op1);
13434           TREE_SET_CODE (node, RSHIFT_EXPR);
13435           TREE_OPERAND (node, 0) = op1;
13436           TREE_OPERAND (node, 1) = op2;
13437           TREE_TYPE (node) = utype;
13438           to_return = convert (prom_type, node);
13439           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13440           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13441           TREE_SIDE_EFFECTS (to_return)
13442             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13443           return to_return;
13444         }
13445       break;
13446
13447       /* 15.19.1 Type Comparison Operator instanceof */
13448     case INSTANCEOF_EXPR:
13449
13450       TREE_TYPE (node) = boolean_type_node;
13451
13452       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13453       if ((cn = patch_string (op1)))
13454         {
13455           op1 = cn;
13456           op1_type = TREE_TYPE (op1);
13457         }
13458       if (op1_type == NULL_TREE)
13459         abort ();
13460
13461       if (!(op2_type = resolve_type_during_patch (op2)))
13462         return error_mark_node;
13463
13464       /* The first operand must be a reference type or the null type */
13465       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13466         error_found = 1;        /* Error reported further below */
13467
13468       /* The second operand must be a reference type */
13469       if (!JREFERENCE_TYPE_P (op2_type))
13470         {
13471           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13472           parse_error_context
13473             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13474              lang_printable_name (op2_type, 0));
13475           error_found = 1;
13476         }
13477
13478       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13479         {
13480           /* If the first operand is null, the result is always false */
13481           if (op1 == null_pointer_node)
13482             return boolean_false_node;
13483           else if (flag_emit_class_files)
13484             {
13485               TREE_OPERAND (node, 1) = op2_type;
13486               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13487               return node;
13488             }
13489           /* Otherwise we have to invoke instance of to figure it out */
13490           else
13491             return build_instanceof (op1, op2_type);
13492         }
13493       /* There is no way the expression operand can be an instance of
13494          the type operand. This is a compile time error. */
13495       else
13496         {
13497           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13498           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13499           parse_error_context
13500             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13501              t1, lang_printable_name (op2_type, 0));
13502           free (t1);
13503           error_found = 1;
13504         }
13505
13506       break;
13507
13508       /* 15.21 Bitwise and Logical Operators */
13509     case BIT_AND_EXPR:
13510     case BIT_XOR_EXPR:
13511     case BIT_IOR_EXPR:
13512       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13513         /* Binary numeric promotion is performed on both operand and the
13514            expression retain that type */
13515         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13516
13517       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13518                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13519         /* The type of the bitwise operator expression is BOOLEAN */
13520         prom_type = boolean_type_node;
13521       else
13522         {
13523           if (!JINTEGRAL_TYPE_P (op1_type))
13524             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13525           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13526             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13527           TREE_TYPE (node) = error_mark_node;
13528           error_found = 1;
13529           /* Insert a break here if adding thing before the switch's
13530              break for this case */
13531         }
13532       break;
13533
13534       /* 15.22 Conditional-And Operator */
13535     case TRUTH_ANDIF_EXPR:
13536       /* 15.23 Conditional-Or Operator */
13537     case TRUTH_ORIF_EXPR:
13538       /* Operands must be of BOOLEAN type */
13539       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13540           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13541         {
13542           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13543             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13544           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13545             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13546           TREE_TYPE (node) = boolean_type_node;
13547           error_found = 1;
13548           break;
13549         }
13550       else if (integer_zerop (op1))
13551         {
13552           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13553         }
13554       else if (integer_onep (op1))
13555         {
13556           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13557         }
13558       /* The type of the conditional operators is BOOLEAN */
13559       prom_type = boolean_type_node;
13560       break;
13561
13562       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13563     case LT_EXPR:
13564     case GT_EXPR:
13565     case LE_EXPR:
13566     case GE_EXPR:
13567       /* The type of each of the operands must be a primitive numeric
13568          type */
13569       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13570         {
13571           if (!JNUMERIC_TYPE_P (op1_type))
13572             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13573           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13574             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13575           TREE_TYPE (node) = boolean_type_node;
13576           error_found = 1;
13577           break;
13578         }
13579       /* Binary numeric promotion is performed on the operands */
13580       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13581       /* The type of the relation expression is always BOOLEAN */
13582       prom_type = boolean_type_node;
13583       break;
13584
13585       /* 15.20 Equality Operator */
13586     case EQ_EXPR:
13587     case NE_EXPR:
13588       /* It's time for us to patch the strings. */
13589       if ((cn = patch_string (op1)))
13590        {
13591          op1 = cn;
13592          op1_type = TREE_TYPE (op1);
13593        }
13594       if ((cn = patch_string (op2)))
13595        {
13596          op2 = cn;
13597          op2_type = TREE_TYPE (op2);
13598        }
13599
13600       /* 15.20.1 Numerical Equality Operators == and != */
13601       /* Binary numeric promotion is performed on the operands */
13602       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13603         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13604
13605       /* 15.20.2 Boolean Equality Operators == and != */
13606       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13607           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13608         ;                       /* Nothing to do here */
13609
13610       /* 15.20.3 Reference Equality Operators == and != */
13611       /* Types have to be either references or the null type. If
13612          they're references, it must be possible to convert either
13613          type to the other by casting conversion. */
13614       else if (op1 == null_pointer_node || op2 == null_pointer_node
13615                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13616                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13617                        || valid_ref_assignconv_cast_p (op2_type,
13618                                                        op1_type, 1))))
13619         ;                       /* Nothing to do here */
13620
13621       /* Else we have an error figure what can't be converted into
13622          what and report the error */
13623       else
13624         {
13625           char *t1;
13626           t1 = xstrdup (lang_printable_name (op1_type, 0));
13627           parse_error_context
13628             (wfl_operator,
13629              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13630              operator_string (node), t1,
13631              lang_printable_name (op2_type, 0));
13632           free (t1);
13633           TREE_TYPE (node) = boolean_type_node;
13634           error_found = 1;
13635           break;
13636         }
13637       prom_type = boolean_type_node;
13638       break;
13639     default:
13640       abort ();
13641     }
13642
13643   if (error_found)
13644     return error_mark_node;
13645
13646   TREE_OPERAND (node, 0) = op1;
13647   TREE_OPERAND (node, 1) = op2;
13648   TREE_TYPE (node) = prom_type;
13649   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13650
13651   if (flag_emit_xref)
13652     return node;
13653
13654   /* fold does not respect side-effect order as required for Java but not C.
13655    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13656    * bytecode.
13657    */
13658   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13659       : ! TREE_SIDE_EFFECTS (node))
13660     node = fold (node);
13661   return node;
13662 }
13663
13664 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13665    zero value, the value of CSTE comes after the valude of STRING */
13666
13667 static tree
13668 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13669 {
13670   const char *old = TREE_STRING_POINTER (cste);
13671   int old_len = TREE_STRING_LENGTH (cste);
13672   int len = old_len + string_len;
13673   char *new = alloca (len+1);
13674
13675   if (after)
13676     {
13677       memcpy (new, string, string_len);
13678       memcpy (&new [string_len], old, old_len);
13679     }
13680   else
13681     {
13682       memcpy (new, old, old_len);
13683       memcpy (&new [old_len], string, string_len);
13684     }
13685   new [len] = '\0';
13686   return build_string (len, new);
13687 }
13688
13689 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13690    new STRING_CST on success, NULL_TREE on failure.  */
13691
13692 static tree
13693 merge_string_cste (tree op1, tree op2, int after)
13694 {
13695   /* Handle two string constants right away.  */
13696   if (TREE_CODE (op2) == STRING_CST)
13697     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13698                                  TREE_STRING_LENGTH (op2), after);
13699
13700   /* Reasonable integer constant can be treated right away.  */
13701   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13702     {
13703       static const char *const boolean_true = "true";
13704       static const char *const boolean_false = "false";
13705       static const char *const null_pointer = "null";
13706       char ch[4];
13707       const char *string;
13708
13709       if (op2 == boolean_true_node)
13710         string = boolean_true;
13711       else if (op2 == boolean_false_node)
13712         string = boolean_false;
13713       else if (op2 == null_pointer_node
13714                || (integer_zerop (op2)
13715                    && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
13716         /* FIXME: null is not a compile-time constant, so it is only safe to
13717            merge if the overall expression is non-constant. However, this
13718            code always merges without checking the overall expression.  */
13719         string = null_pointer;
13720       else if (TREE_TYPE (op2) == char_type_node)
13721         {
13722           /* Convert the character into UTF-8.  */
13723           unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13724           unsigned char *p = (unsigned char *) ch;
13725           if (0x01 <= c && c <= 0x7f)
13726             *p++ = (unsigned char) c;
13727           else if (c < 0x7ff)
13728             {
13729               *p++ = (unsigned char) (c >> 6 | 0xc0);
13730               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13731             }
13732           else
13733             {
13734               *p++ = (unsigned char) (c >> 12 | 0xe0);
13735               *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13736               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13737             }
13738           *p = '\0';
13739
13740           string = ch;
13741         }
13742       else
13743         string = string_convert_int_cst (op2);
13744
13745       return do_merge_string_cste (op1, string, strlen (string), after);
13746     }
13747   return NULL_TREE;
13748 }
13749
13750 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13751    has to be a STRING_CST and the other part must be a STRING_CST or a
13752    INTEGRAL constant. Return a new STRING_CST if the operation
13753    succeed, NULL_TREE otherwise.
13754
13755    If the case we want to optimize for space, we might want to return
13756    NULL_TREE for each invocation of this routine. FIXME */
13757
13758 static tree
13759 string_constant_concatenation (tree op1, tree op2)
13760 {
13761   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13762     {
13763       tree string, rest;
13764       int invert;
13765
13766       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13767       rest   = (string == op1 ? op2 : op1);
13768       invert = (string == op1 ? 0 : 1 );
13769
13770       /* Walk REST, only if it looks reasonable */
13771       if (TREE_CODE (rest) != STRING_CST
13772           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13773           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13774           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13775         {
13776           rest = java_complete_tree (rest);
13777           if (rest == error_mark_node)
13778             return error_mark_node;
13779           rest = fold (rest);
13780         }
13781       return merge_string_cste (string, rest, invert);
13782     }
13783   return NULL_TREE;
13784 }
13785
13786 /* Implement the `+' operator. Does static optimization if possible,
13787    otherwise create (if necessary) and append elements to a
13788    StringBuffer. The StringBuffer will be carried around until it is
13789    used for a function call or an assignment. Then toString() will be
13790    called on it to turn it into a String object. */
13791
13792 static tree
13793 build_string_concatenation (tree op1, tree op2)
13794 {
13795   tree result;
13796   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13797
13798   if (flag_emit_xref)
13799     return build (PLUS_EXPR, string_type_node, op1, op2);
13800
13801   /* Try to do some static optimization */
13802   if ((result = string_constant_concatenation (op1, op2)))
13803     return result;
13804
13805   /* Discard empty strings on either side of the expression */
13806   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13807     {
13808       op1 = op2;
13809       op2 = NULL_TREE;
13810     }
13811   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13812     op2 = NULL_TREE;
13813
13814   /* If operands are string constant, turn then into object references */
13815   if (TREE_CODE (op1) == STRING_CST)
13816     op1 = patch_string_cst (op1);
13817   if (op2 && TREE_CODE (op2) == STRING_CST)
13818     op2 = patch_string_cst (op2);
13819
13820   /* If either one of the constant is null and the other non null
13821      operand is a String constant, return it. */
13822   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13823     return op1;
13824
13825   /* If OP1 isn't already a StringBuffer, create and
13826      initialize a new one */
13827   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13828     {
13829       /* Two solutions here:
13830          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13831          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13832       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13833         op1 = BUILD_STRING_BUFFER (op1);
13834       else
13835         {
13836           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13837           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13838         }
13839     }
13840
13841   if (op2)
13842     {
13843       /* OP1 is no longer the last node holding a crafted StringBuffer */
13844       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13845       /* Create a node for `{new...,xxx}.append (op2)' */
13846       if (op2)
13847         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13848     }
13849
13850   /* Mark the last node holding a crafted StringBuffer */
13851   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13852
13853   TREE_SIDE_EFFECTS (op1) = side_effects;
13854   return op1;
13855 }
13856
13857 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13858    StringBuffer. If no string were found to be patched, return
13859    NULL. */
13860
13861 static tree
13862 patch_string (tree node)
13863 {
13864   if (node == error_mark_node)
13865     return error_mark_node;
13866   if (TREE_CODE (node) == STRING_CST)
13867     return patch_string_cst (node);
13868   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13869     {
13870       int saved = ctxp->explicit_constructor_p;
13871       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13872       tree ret;
13873       /* Temporary disable forbid the use of `this'. */
13874       ctxp->explicit_constructor_p = 0;
13875       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13876       /* String concatenation arguments must be evaluated in order too. */
13877       ret = force_evaluation_order (ret);
13878       /* Restore it at its previous value */
13879       ctxp->explicit_constructor_p = saved;
13880       return ret;
13881     }
13882   return NULL_TREE;
13883 }
13884
13885 /* Build the internal representation of a string constant.  */
13886
13887 static tree
13888 patch_string_cst (tree node)
13889 {
13890   int location;
13891   if (! flag_emit_class_files)
13892     {
13893       node = get_identifier (TREE_STRING_POINTER (node));
13894       location = alloc_name_constant (CONSTANT_String, node);
13895       node = build_ref_from_constant_pool (location);
13896     }
13897   TREE_TYPE (node) = string_ptr_type_node;
13898   TREE_CONSTANT (node) = 1;
13899   return node;
13900 }
13901
13902 /* Build an incomplete unary operator expression. */
13903
13904 static tree
13905 build_unaryop (int op_token, int op_location, tree op1)
13906 {
13907   enum tree_code op;
13908   tree unaryop;
13909   switch (op_token)
13910     {
13911     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13912     case MINUS_TK: op = NEGATE_EXPR; break;
13913     case NEG_TK: op = TRUTH_NOT_EXPR; break;
13914     case NOT_TK: op = BIT_NOT_EXPR; break;
13915     default: abort ();
13916     }
13917
13918   unaryop = build1 (op, NULL_TREE, op1);
13919   TREE_SIDE_EFFECTS (unaryop) = 1;
13920   /* Store the location of the operator, for better error report. The
13921      string of the operator will be rebuild based on the OP value. */
13922   EXPR_WFL_LINECOL (unaryop) = op_location;
13923   return unaryop;
13924 }
13925
13926 /* Special case for the ++/-- operators, since they require an extra
13927    argument to build, which is set to NULL and patched
13928    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
13929
13930 static tree
13931 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
13932 {
13933   static const enum tree_code lookup [2][2] =
13934     {
13935       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
13936       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
13937     };
13938   tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
13939                      NULL_TREE, op1, NULL_TREE);
13940   TREE_SIDE_EFFECTS (node) = 1;
13941   /* Store the location of the operator, for better error report. The
13942      string of the operator will be rebuild based on the OP value. */
13943   EXPR_WFL_LINECOL (node) = op_location;
13944   return node;
13945 }
13946
13947 /* Build an incomplete cast operator, based on the use of the
13948    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13949    set. java_complete_tree is trained to walk a CONVERT_EXPR even
13950    though its type is already set.  */
13951
13952 static tree
13953 build_cast (int location, tree type, tree exp)
13954 {
13955   tree node = build1 (CONVERT_EXPR, type, exp);
13956   EXPR_WFL_LINECOL (node) = location;
13957   return node;
13958 }
13959
13960 /* Build an incomplete class reference operator.  */
13961 static tree
13962 build_incomplete_class_ref (int location, tree class_name)
13963 {
13964   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13965   tree class_decl = GET_CPC ();
13966   tree this_class = TREE_TYPE (class_decl);
13967
13968   /* Generate the synthetic static method `class$'.  (Previously we
13969      deferred this, causing different method tables to be emitted
13970      for native code and bytecode.)  */
13971   if (!TYPE_DOT_CLASS (this_class)
13972       && !JPRIMITIVE_TYPE_P (class_name)
13973       && !(TREE_CODE (class_name) == VOID_TYPE))
13974     {
13975       tree target_class;
13976
13977       if (CLASS_INTERFACE (TYPE_NAME (this_class)))
13978         {
13979           /* For interfaces, adding a static 'class$' method directly
13980              is illegal.  So create an inner class to contain the new
13981              method.  Empirically this matches the behavior of javac.  */
13982           tree t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
13983           tree inner = create_anonymous_class (0, t);
13984           target_class = TREE_TYPE (inner);
13985           end_class_declaration (1);
13986         }
13987       else
13988         {
13989           /* For inner classes, add a 'class$' method to their outermost
13990              context, creating it if necessary.  */
13991           while (INNER_CLASS_DECL_P (class_decl))
13992             class_decl = DECL_CONTEXT (class_decl);
13993           target_class = TREE_TYPE (class_decl);
13994         }
13995
13996       if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
13997         build_dot_class_method (target_class);
13998
13999       if (this_class != target_class)
14000         TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
14001     }
14002
14003   EXPR_WFL_LINECOL (node) = location;
14004   return node;
14005 }
14006
14007 /* Complete an incomplete class reference operator.  */
14008 static tree
14009 patch_incomplete_class_ref (tree node)
14010 {
14011   tree type = TREE_OPERAND (node, 0);
14012   tree ref_type;
14013
14014   if (!(ref_type = resolve_type_during_patch (type)))
14015     return error_mark_node;
14016
14017   /* If we're not emitting class files and we know ref_type is a
14018      compiled class, build a direct reference.  */
14019   if ((! flag_emit_class_files && is_compiled_class (ref_type))
14020       || JPRIMITIVE_TYPE_P (ref_type)
14021       || TREE_CODE (ref_type) == VOID_TYPE)
14022     {
14023       tree dot = build_class_ref (ref_type);
14024       /* A class referenced by `foo.class' is initialized.  */
14025       if (!flag_emit_class_files)
14026        dot = build_class_init (ref_type, dot);
14027       return java_complete_tree (dot);
14028     }
14029
14030   /* If we're emitting class files and we have to deal with non
14031      primitive types, we invoke the synthetic static method `class$'.  */
14032   ref_type = build_dot_class_method_invocation (current_class, ref_type);
14033   return java_complete_tree (ref_type);
14034 }
14035
14036 /* 15.14 Unary operators. We return error_mark_node in case of error,
14037    but preserve the type of NODE if the type is fixed.  */
14038
14039 static tree
14040 patch_unaryop (tree node, tree wfl_op)
14041 {
14042   tree op = TREE_OPERAND (node, 0);
14043   tree op_type = TREE_TYPE (op);
14044   tree prom_type = NULL_TREE, value, decl;
14045   int outer_field_flag = 0;
14046   int code = TREE_CODE (node);
14047   int error_found = 0;
14048
14049   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14050
14051   switch (code)
14052     {
14053       /* 15.13.2 Postfix Increment Operator ++ */
14054     case POSTINCREMENT_EXPR:
14055       /* 15.13.3 Postfix Increment Operator -- */
14056     case POSTDECREMENT_EXPR:
14057       /* 15.14.1 Prefix Increment Operator ++ */
14058     case PREINCREMENT_EXPR:
14059       /* 15.14.2 Prefix Decrement Operator -- */
14060     case PREDECREMENT_EXPR:
14061       op = decl = strip_out_static_field_access_decl (op);
14062       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14063       /* We might be trying to change an outer field accessed using
14064          access method. */
14065       if (outer_field_flag)
14066         {
14067           /* Retrieve the decl of the field we're trying to access. We
14068              do that by first retrieving the function we would call to
14069              access the field. It has been already verified that this
14070              field isn't final */
14071           if (flag_emit_class_files)
14072             decl = TREE_OPERAND (op, 0);
14073           else
14074             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14075           decl = DECL_FUNCTION_ACCESS_DECL (decl);
14076         }
14077       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14078       else if (!JDECL_P (decl)
14079           && TREE_CODE (decl) != COMPONENT_REF
14080           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14081           && TREE_CODE (decl) != INDIRECT_REF
14082           && !(TREE_CODE (decl) == COMPOUND_EXPR
14083                && TREE_OPERAND (decl, 1)
14084                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14085         {
14086           TREE_TYPE (node) = error_mark_node;
14087           error_found = 1;
14088         }
14089
14090       /* From now on, we know that op if a variable and that it has a
14091          valid wfl. We use wfl_op to locate errors related to the
14092          ++/-- operand. */
14093       if (!JNUMERIC_TYPE_P (op_type))
14094         {
14095           parse_error_context
14096             (wfl_op, "Invalid argument type `%s' to `%s'",
14097              lang_printable_name (op_type, 0), operator_string (node));
14098           TREE_TYPE (node) = error_mark_node;
14099           error_found = 1;
14100         }
14101       else
14102         {
14103           /* Before the addition, binary numeric promotion is performed on
14104              both operands, if really necessary */
14105           if (JINTEGRAL_TYPE_P (op_type))
14106             {
14107               value = build_int_2 (1, 0);
14108               TREE_TYPE (value) = TREE_TYPE (node) = op_type;
14109             }
14110           else
14111             {
14112               value = build_int_2 (1, 0);
14113               TREE_TYPE (node) =
14114                 binary_numeric_promotion (op_type,
14115                                           TREE_TYPE (value), &op, &value);
14116             }
14117
14118           /* We remember we might be accessing an outer field */
14119           if (outer_field_flag)
14120             {
14121               /* We re-generate an access to the field */
14122               value = build (PLUS_EXPR, TREE_TYPE (op),
14123                              build_outer_field_access (wfl_op, decl), value);
14124
14125               /* And we patch the original access$() into a write
14126                  with plus_op as a rhs */
14127               return outer_field_access_fix (node, op, value);
14128             }
14129
14130           /* And write back into the node. */
14131           TREE_OPERAND (node, 0) = op;
14132           TREE_OPERAND (node, 1) = value;
14133           /* Convert the overall back into its original type, if
14134              necessary, and return */
14135           if (JINTEGRAL_TYPE_P (op_type))
14136             return fold (node);
14137           else
14138             return fold (convert (op_type, node));
14139         }
14140       break;
14141
14142       /* 15.14.3 Unary Plus Operator + */
14143     case UNARY_PLUS_EXPR:
14144       /* 15.14.4 Unary Minus Operator - */
14145     case NEGATE_EXPR:
14146       if (!JNUMERIC_TYPE_P (op_type))
14147         {
14148           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14149           TREE_TYPE (node) = error_mark_node;
14150           error_found = 1;
14151         }
14152       /* Unary numeric promotion is performed on operand */
14153       else
14154         {
14155           op = do_unary_numeric_promotion (op);
14156           prom_type = TREE_TYPE (op);
14157           if (code == UNARY_PLUS_EXPR)
14158             return fold (op);
14159         }
14160       break;
14161
14162       /* 15.14.5 Bitwise Complement Operator ~ */
14163     case BIT_NOT_EXPR:
14164       if (!JINTEGRAL_TYPE_P (op_type))
14165         {
14166           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14167           TREE_TYPE (node) = error_mark_node;
14168           error_found = 1;
14169         }
14170       else
14171         {
14172           op = do_unary_numeric_promotion (op);
14173           prom_type = TREE_TYPE (op);
14174         }
14175       break;
14176
14177       /* 15.14.6 Logical Complement Operator ! */
14178     case TRUTH_NOT_EXPR:
14179       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14180         {
14181           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14182           /* But the type is known. We will report an error if further
14183              attempt of a assignment is made with this rhs */
14184           TREE_TYPE (node) = boolean_type_node;
14185           error_found = 1;
14186         }
14187       else
14188         prom_type = boolean_type_node;
14189       break;
14190
14191       /* 15.15 Cast Expression */
14192     case CONVERT_EXPR:
14193       value = patch_cast (node, wfl_operator);
14194       if (value == error_mark_node)
14195         {
14196           /* If this cast is part of an assignment, we tell the code
14197              that deals with it not to complain about a mismatch,
14198              because things have been cast, anyways */
14199           TREE_TYPE (node) = error_mark_node;
14200           error_found = 1;
14201         }
14202       else
14203         {
14204           value = fold (value);
14205           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14206           return value;
14207         }
14208       break;
14209     }
14210
14211   if (error_found)
14212     return error_mark_node;
14213
14214   /* There are cases where node has been replaced by something else
14215      and we don't end up returning here: UNARY_PLUS_EXPR,
14216      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14217   TREE_OPERAND (node, 0) = fold (op);
14218   TREE_TYPE (node) = prom_type;
14219   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14220   return fold (node);
14221 }
14222
14223 /* Generic type resolution that sometimes takes place during node
14224    patching. Returned the resolved type or generate an error
14225    message. Return the resolved type or NULL_TREE.  */
14226
14227 static tree
14228 resolve_type_during_patch (tree type)
14229 {
14230   if (unresolved_type_p (type, NULL))
14231     {
14232       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14233       if (!type_decl)
14234         {
14235           parse_error_context (type,
14236                                "Class `%s' not found in type declaration",
14237                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14238           return NULL_TREE;
14239         }
14240
14241       check_deprecation (type, type_decl);
14242
14243       return TREE_TYPE (type_decl);
14244     }
14245   return type;
14246 }
14247
14248 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14249    found. Otherwise NODE or something meant to replace it is returned.  */
14250
14251 static tree
14252 patch_cast (tree node, tree wfl_op)
14253 {
14254   tree op = TREE_OPERAND (node, 0);
14255   tree cast_type = TREE_TYPE (node);
14256   tree patched, op_type;
14257   char *t1;
14258
14259   /* Some string patching might be necessary at this stage */
14260   if ((patched = patch_string (op)))
14261     TREE_OPERAND (node, 0) = op = patched;
14262   op_type = TREE_TYPE (op);
14263
14264   /* First resolve OP_TYPE if unresolved */
14265   if (!(cast_type = resolve_type_during_patch (cast_type)))
14266     return error_mark_node;
14267
14268   /* Check on cast that are proven correct at compile time */
14269   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14270     {
14271       /* Same type */
14272       if (cast_type == op_type)
14273         return node;
14274
14275       /* A narrowing conversion from a floating-point number to an
14276          integral type requires special handling (5.1.3).  */
14277       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14278         if (cast_type != long_type_node)
14279           op = convert (integer_type_node, op);
14280
14281       /* Try widening/narrowing conversion.  Potentially, things need
14282          to be worked out in gcc so we implement the extreme cases
14283          correctly.  fold_convert() needs to be fixed.  */
14284       return convert (cast_type, op);
14285     }
14286
14287   /* It's also valid to cast a boolean into a boolean */
14288   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14289     return node;
14290
14291   /* null can be casted to references */
14292   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14293     return build_null_of_type (cast_type);
14294
14295   /* The remaining legal casts involve conversion between reference
14296      types. Check for their compile time correctness. */
14297   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14298       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14299     {
14300       TREE_TYPE (node) = promote_type (cast_type);
14301       /* Now, the case can be determined correct at compile time if
14302          OP_TYPE can be converted into CAST_TYPE by assignment
14303          conversion (5.2) */
14304
14305       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14306         {
14307           TREE_SET_CODE (node, NOP_EXPR);
14308           return node;
14309         }
14310
14311       if (flag_emit_class_files)
14312         {
14313           TREE_SET_CODE (node, CONVERT_EXPR);
14314           return node;
14315         }
14316
14317       /* The cast requires a run-time check */
14318       return build (CALL_EXPR, promote_type (cast_type),
14319                     build_address_of (soft_checkcast_node),
14320                     tree_cons (NULL_TREE, build_class_ref (cast_type),
14321                                build_tree_list (NULL_TREE, op)),
14322                     NULL_TREE);
14323     }
14324
14325   /* Any other casts are proven incorrect at compile time */
14326   t1 = xstrdup (lang_printable_name (op_type, 0));
14327   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14328                        t1, lang_printable_name (cast_type, 0));
14329   free (t1);
14330   return error_mark_node;
14331 }
14332
14333 /* Build a null constant and give it the type TYPE.  */
14334
14335 static tree
14336 build_null_of_type (tree type)
14337 {
14338   tree node = build_int_2 (0, 0);
14339   TREE_TYPE (node) = promote_type (type);
14340   return node;
14341 }
14342
14343 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14344    a list of indices. */
14345 static tree
14346 build_array_ref (int location, tree array, tree index)
14347 {
14348   tree node = build (ARRAY_REF, NULL_TREE, array, index);
14349   EXPR_WFL_LINECOL (node) = location;
14350   return node;
14351 }
14352
14353 /* 15.12 Array Access Expression */
14354
14355 static tree
14356 patch_array_ref (tree node)
14357 {
14358   tree array = TREE_OPERAND (node, 0);
14359   tree array_type  = TREE_TYPE (array);
14360   tree index = TREE_OPERAND (node, 1);
14361   tree index_type = TREE_TYPE (index);
14362   int error_found = 0;
14363
14364   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14365
14366   if (TREE_CODE (array_type) == POINTER_TYPE)
14367     array_type = TREE_TYPE (array_type);
14368
14369   /* The array reference must be an array */
14370   if (!TYPE_ARRAY_P (array_type))
14371     {
14372       parse_error_context
14373         (wfl_operator,
14374          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14375          lang_printable_name (array_type, 0));
14376       TREE_TYPE (node) = error_mark_node;
14377       error_found = 1;
14378     }
14379
14380   /* The array index undergoes unary numeric promotion. The promoted
14381      type must be int */
14382   index = do_unary_numeric_promotion (index);
14383   if (TREE_TYPE (index) != int_type_node)
14384     {
14385       if (valid_cast_to_p (index_type, int_type_node))
14386         parse_error_context (wfl_operator,
14387    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14388                              lang_printable_name (index_type, 0));
14389       else
14390         parse_error_context (wfl_operator,
14391           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14392                              lang_printable_name (index_type, 0));
14393       TREE_TYPE (node) = error_mark_node;
14394       error_found = 1;
14395     }
14396
14397   if (error_found)
14398     return error_mark_node;
14399
14400   array_type = TYPE_ARRAY_ELEMENT (array_type);
14401
14402   if (flag_emit_class_files || flag_emit_xref)
14403     {
14404       TREE_OPERAND (node, 0) = array;
14405       TREE_OPERAND (node, 1) = index;
14406     }
14407   else
14408     node = build_java_arrayaccess (array, array_type, index);
14409   TREE_TYPE (node) = array_type;
14410   return node;
14411 }
14412
14413 /* 15.9 Array Creation Expressions */
14414
14415 static tree
14416 build_newarray_node (tree type, tree dims, int extra_dims)
14417 {
14418   tree node =
14419     build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
14420            build_int_2 (extra_dims, 0));
14421   return node;
14422 }
14423
14424 static tree
14425 patch_newarray (tree node)
14426 {
14427   tree type = TREE_OPERAND (node, 0);
14428   tree dims = TREE_OPERAND (node, 1);
14429   tree cdim, array_type;
14430   int error_found = 0;
14431   int ndims = 0;
14432   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14433
14434   /* Dimension types are verified. It's better for the types to be
14435      verified in order. */
14436   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14437     {
14438       int dim_error = 0;
14439       tree dim = TREE_VALUE (cdim);
14440
14441       /* Dim might have been saved during its evaluation */
14442       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14443
14444       /* The type of each specified dimension must be an integral type. */
14445       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14446         dim_error = 1;
14447
14448       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14449          promoted type must be int. */
14450       else
14451         {
14452           dim = do_unary_numeric_promotion (dim);
14453           if (TREE_TYPE (dim) != int_type_node)
14454             dim_error = 1;
14455         }
14456
14457       /* Report errors on types here */
14458       if (dim_error)
14459         {
14460           parse_error_context
14461             (TREE_PURPOSE (cdim),
14462              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14463              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14464               "Explicit cast needed to" : "Can't"),
14465              lang_printable_name (TREE_TYPE (dim), 0));
14466           error_found = 1;
14467         }
14468
14469       TREE_PURPOSE (cdim) = NULL_TREE;
14470     }
14471
14472   /* Resolve array base type if unresolved */
14473   if (!(type = resolve_type_during_patch (type)))
14474     error_found = 1;
14475
14476   if (error_found)
14477     {
14478       /* We don't want further evaluation of this bogus array creation
14479          operation */
14480       TREE_TYPE (node) = error_mark_node;
14481       return error_mark_node;
14482     }
14483
14484   /* Set array_type to the actual (promoted) array type of the result. */
14485   if (TREE_CODE (type) == RECORD_TYPE)
14486     type = build_pointer_type (type);
14487   while (--xdims >= 0)
14488     {
14489       type = promote_type (build_java_array_type (type, -1));
14490     }
14491   dims = nreverse (dims);
14492   array_type = type;
14493   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14494     {
14495       type = array_type;
14496       array_type
14497         = build_java_array_type (type,
14498                                  TREE_CODE (cdim) == INTEGER_CST
14499                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14500                                  : -1);
14501       array_type = promote_type (array_type);
14502     }
14503   dims = nreverse (dims);
14504
14505   /* The node is transformed into a function call. Things are done
14506      differently according to the number of dimensions. If the number
14507      of dimension is equal to 1, then the nature of the base type
14508      (primitive or not) matters. */
14509   if (ndims == 1)
14510     return build_new_array (type, TREE_VALUE (dims));
14511
14512   /* Can't reuse what's already written in expr.c because it uses the
14513      JVM stack representation. Provide a build_multianewarray. FIXME */
14514   return build (CALL_EXPR, array_type,
14515                 build_address_of (soft_multianewarray_node),
14516                 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
14517                            tree_cons (NULL_TREE,
14518                                       build_int_2 (ndims, 0), dims )),
14519                 NULL_TREE);
14520 }
14521
14522 /* 10.6 Array initializer.  */
14523
14524 /* Build a wfl for array element that don't have one, so we can
14525    pin-point errors.  */
14526
14527 static tree
14528 maybe_build_array_element_wfl (tree node)
14529 {
14530   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14531     return build_expr_wfl (NULL_TREE, ctxp->filename,
14532                            ctxp->elc.line, ctxp->elc.prev_col);
14533   else
14534     return NULL_TREE;
14535 }
14536
14537 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14538    identification of initialized arrays easier to detect during walk
14539    and expansion.  */
14540
14541 static tree
14542 build_new_array_init (int location, tree values)
14543 {
14544   tree constructor = build_constructor (NULL_TREE, values);
14545   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14546   EXPR_WFL_LINECOL (to_return) = location;
14547   return to_return;
14548 }
14549
14550 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14551    occurred.  Otherwise return NODE after having set its type
14552    appropriately.  */
14553
14554 static tree
14555 patch_new_array_init (tree type, tree node)
14556 {
14557   int error_seen = 0;
14558   tree current, element_type;
14559   HOST_WIDE_INT length;
14560   int all_constant = 1;
14561   tree init = TREE_OPERAND (node, 0);
14562
14563   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14564     {
14565       parse_error_context (node,
14566                            "Invalid array initializer for non-array type `%s'",
14567                            lang_printable_name (type, 1));
14568       return error_mark_node;
14569     }
14570   type = TREE_TYPE (type);
14571   element_type = TYPE_ARRAY_ELEMENT (type);
14572
14573   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14574
14575   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14576        current;  length++, current = TREE_CHAIN (current))
14577     {
14578       tree elt = TREE_VALUE (current);
14579       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14580         {
14581           error_seen |= array_constructor_check_entry (element_type, current);
14582           elt = TREE_VALUE (current);
14583           /* When compiling to native code, STRING_CST is converted to
14584              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14585           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14586             all_constant = 0;
14587         }
14588       else
14589         {
14590           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14591           TREE_PURPOSE (current) = NULL_TREE;
14592           all_constant = 0;
14593         }
14594       if (elt && TREE_CODE (elt) == TREE_LIST
14595           && TREE_VALUE (elt) == error_mark_node)
14596         error_seen = 1;
14597     }
14598
14599   if (error_seen)
14600     return error_mark_node;
14601
14602   /* Create a new type. We can't reuse the one we have here by
14603      patching its dimension because it originally is of dimension -1
14604      hence reused by gcc. This would prevent triangular arrays. */
14605   type = build_java_array_type (element_type, length);
14606   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14607   TREE_TYPE (node) = promote_type (type);
14608   TREE_CONSTANT (init) = all_constant;
14609   TREE_CONSTANT (node) = all_constant;
14610   return node;
14611 }
14612
14613 /* Verify that one entry of the initializer element list can be
14614    assigned to the array base type. Report 1 if an error occurred, 0
14615    otherwise.  */
14616
14617 static int
14618 array_constructor_check_entry (tree type, tree entry)
14619 {
14620   char *array_type_string = NULL;       /* For error reports */
14621   tree value, type_value, new_value, wfl_value, patched;
14622   int error_seen = 0;
14623
14624   new_value = NULL_TREE;
14625   wfl_value = TREE_VALUE (entry);
14626
14627   value = java_complete_tree (TREE_VALUE (entry));
14628   /* patch_string return error_mark_node if arg is error_mark_node */
14629   if ((patched = patch_string (value)))
14630     value = patched;
14631   if (value == error_mark_node)
14632     return 1;
14633
14634   type_value = TREE_TYPE (value);
14635
14636   /* At anytime, try_builtin_assignconv can report a warning on
14637      constant overflow during narrowing. */
14638   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14639   new_value = try_builtin_assignconv (wfl_operator, type, value);
14640   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14641     type_value = promote_type (type);
14642
14643   /* Check and report errors */
14644   if (!new_value)
14645     {
14646       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14647                    "Can't" : "Explicit cast needed to");
14648       if (!array_type_string)
14649         array_type_string = xstrdup (lang_printable_name (type, 1));
14650       parse_error_context
14651         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14652          msg, lang_printable_name (type_value, 1), array_type_string);
14653       error_seen = 1;
14654     }
14655
14656   if (new_value)
14657     TREE_VALUE (entry) = new_value;
14658
14659   if (array_type_string)
14660     free (array_type_string);
14661
14662   TREE_PURPOSE (entry) = NULL_TREE;
14663   return error_seen;
14664 }
14665
14666 static tree
14667 build_this (int location)
14668 {
14669   tree node = build_wfl_node (this_identifier_node);
14670   TREE_SET_CODE (node, THIS_EXPR);
14671   EXPR_WFL_LINECOL (node) = location;
14672   return node;
14673 }
14674
14675 /* 14.15 The return statement. It builds a modify expression that
14676    assigns the returned value to the RESULT_DECL that hold the value
14677    to be returned. */
14678
14679 static tree
14680 build_return (int location, tree op)
14681 {
14682   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14683   EXPR_WFL_LINECOL (node) = location;
14684   node = build_debugable_stmt (location, node);
14685   return node;
14686 }
14687
14688 static tree
14689 patch_return (tree node)
14690 {
14691   tree return_exp = TREE_OPERAND (node, 0);
14692   tree meth = current_function_decl;
14693   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14694   int error_found = 0;
14695
14696   TREE_TYPE (node) = error_mark_node;
14697   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14698
14699   /* It's invalid to have a return value within a function that is
14700      declared with the keyword void or that is a constructor */
14701   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14702     error_found = 1;
14703
14704   /* It's invalid to use a return statement in a static block */
14705   if (DECL_CLINIT_P (current_function_decl))
14706     error_found = 1;
14707
14708   /* It's invalid to have a no return value within a function that
14709      isn't declared with the keyword `void' */
14710   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14711     error_found = 2;
14712
14713   if (DECL_INSTINIT_P (current_function_decl))
14714     error_found = 1;
14715
14716   if (error_found)
14717     {
14718       if (DECL_INSTINIT_P (current_function_decl))
14719         parse_error_context (wfl_operator,
14720                              "`return' inside instance initializer");
14721
14722       else if (DECL_CLINIT_P (current_function_decl))
14723         parse_error_context (wfl_operator,
14724                              "`return' inside static initializer");
14725
14726       else if (!DECL_CONSTRUCTOR_P (meth))
14727         {
14728           char *t = xstrdup (lang_printable_name (mtype, 0));
14729           parse_error_context (wfl_operator,
14730                                "`return' with%s value from `%s %s'",
14731                                (error_found == 1 ? "" : "out"),
14732                                t, lang_printable_name (meth, 0));
14733           free (t);
14734         }
14735       else
14736         parse_error_context (wfl_operator,
14737                              "`return' with value from constructor `%s'",
14738                              lang_printable_name (meth, 0));
14739       return error_mark_node;
14740     }
14741
14742   /* If we have a return_exp, build a modify expression and expand
14743      it. Note: at that point, the assignment is declared valid, but we
14744      may want to carry some more hacks */
14745   if (return_exp)
14746     {
14747       tree exp = java_complete_tree (return_exp);
14748       tree modify, patched;
14749
14750       if ((patched = patch_string (exp)))
14751         exp = patched;
14752
14753       modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14754       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14755       modify = java_complete_tree (modify);
14756
14757       if (modify != error_mark_node)
14758         {
14759           TREE_SIDE_EFFECTS (modify) = 1;
14760           TREE_OPERAND (node, 0) = modify;
14761         }
14762       else
14763         return error_mark_node;
14764     }
14765   TREE_TYPE (node) = void_type_node;
14766   TREE_SIDE_EFFECTS (node) = 1;
14767   return node;
14768 }
14769
14770 /* 14.8 The if Statement */
14771
14772 static tree
14773 build_if_else_statement (int location, tree expression, tree if_body,
14774                          tree else_body)
14775 {
14776   tree node;
14777   if (!else_body)
14778     else_body = empty_stmt_node;
14779   node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14780   EXPR_WFL_LINECOL (node) = location;
14781   node = build_debugable_stmt (location, node);
14782   return node;
14783 }
14784
14785 static tree
14786 patch_if_else_statement (tree node)
14787 {
14788   tree expression = TREE_OPERAND (node, 0);
14789   int can_complete_normally
14790     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14791        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14792
14793   TREE_TYPE (node) = error_mark_node;
14794   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14795
14796   /* The type of expression must be boolean */
14797   if (TREE_TYPE (expression) != boolean_type_node
14798       && TREE_TYPE (expression) != promoted_boolean_type_node)
14799     {
14800       parse_error_context
14801         (wfl_operator,
14802          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14803          lang_printable_name (TREE_TYPE (expression), 0));
14804       return error_mark_node;
14805     }
14806
14807   if (TREE_CODE (expression) == INTEGER_CST)
14808     {
14809       if (integer_zerop (expression))
14810         node = TREE_OPERAND (node, 2);
14811       else
14812         node = TREE_OPERAND (node, 1);
14813       if (CAN_COMPLETE_NORMALLY (node) != can_complete_normally)
14814         {
14815           node = build (COMPOUND_EXPR, void_type_node, node, empty_stmt_node);
14816           CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14817         }
14818       return node;
14819     }
14820   TREE_TYPE (node) = void_type_node;
14821   TREE_SIDE_EFFECTS (node) = 1;
14822   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14823   return node;
14824 }
14825
14826 /* 14.6 Labeled Statements */
14827
14828 /* Action taken when a labeled statement is parsed. a new
14829    LABELED_BLOCK_EXPR is created. No statement is attached to the
14830    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14831
14832 static tree
14833 build_labeled_block (int location, tree label)
14834 {
14835   tree label_name ;
14836   tree label_decl, node;
14837   if (label == NULL_TREE || label == continue_identifier_node)
14838     label_name = label;
14839   else
14840     {
14841       label_name = merge_qualified_name (label_id, label);
14842       /* Issue an error if we try to reuse a label that was previously
14843          declared */
14844       if (IDENTIFIER_LOCAL_VALUE (label_name))
14845         {
14846           EXPR_WFL_LINECOL (wfl_operator) = location;
14847           parse_error_context (wfl_operator,
14848             "Declaration of `%s' shadows a previous label declaration",
14849                                IDENTIFIER_POINTER (label));
14850           EXPR_WFL_LINECOL (wfl_operator) =
14851             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14852           parse_error_context (wfl_operator,
14853             "This is the location of the previous declaration of label `%s'",
14854                                IDENTIFIER_POINTER (label));
14855           java_error_count--;
14856         }
14857     }
14858
14859   label_decl = create_label_decl (label_name);
14860   node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14861   EXPR_WFL_LINECOL (node) = location;
14862   TREE_SIDE_EFFECTS (node) = 1;
14863   return node;
14864 }
14865
14866 /* A labeled statement LBE is attached a statement.  */
14867
14868 static tree
14869 finish_labeled_statement (tree lbe, /* Labeled block expr */
14870                           tree statement)
14871 {
14872   /* In anyways, tie the loop to its statement */
14873   LABELED_BLOCK_BODY (lbe) = statement;
14874   pop_labeled_block ();
14875   POP_LABELED_BLOCK ();
14876   return lbe;
14877 }
14878
14879 /* 14.10, 14.11, 14.12 Loop Statements */
14880
14881 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14882    list. */
14883
14884 static tree
14885 build_new_loop (tree loop_body)
14886 {
14887   tree loop =  build (LOOP_EXPR, NULL_TREE, loop_body);
14888   TREE_SIDE_EFFECTS (loop) = 1;
14889   PUSH_LOOP (loop);
14890   return loop;
14891 }
14892
14893 /* Create a loop body according to the following structure:
14894      COMPOUND_EXPR
14895        COMPOUND_EXPR            (loop main body)
14896          EXIT_EXPR              (this order is for while/for loops.
14897          LABELED_BLOCK_EXPR      the order is reversed for do loops)
14898            LABEL_DECL           (a continue occurring here branches at the
14899            BODY                  end of this labeled block)
14900        INCREMENT                (if any)
14901
14902   REVERSED, if nonzero, tells that the loop condition expr comes
14903   after the body, like in the do-while loop.
14904
14905   To obtain a loop, the loop body structure described above is
14906   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14907
14908    LABELED_BLOCK_EXPR
14909      LABEL_DECL                   (use this label to exit the loop)
14910      LOOP_EXPR
14911        <structure described above> */
14912
14913 static tree
14914 build_loop_body (int location, tree condition, int reversed)
14915 {
14916   tree first, second, body;
14917
14918   condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14919   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14920   condition = build_debugable_stmt (location, condition);
14921   TREE_SIDE_EFFECTS (condition) = 1;
14922
14923   body = build_labeled_block (0, continue_identifier_node);
14924   first = (reversed ? body : condition);
14925   second = (reversed ? condition : body);
14926   return
14927     build (COMPOUND_EXPR, NULL_TREE,
14928            build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
14929 }
14930
14931 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14932    their order) on the current loop. Unlink the current loop from the
14933    loop list.  */
14934
14935 static tree
14936 finish_loop_body (int location, tree condition, tree body, int reversed)
14937 {
14938   tree to_return = ctxp->current_loop;
14939   tree loop_body = LOOP_EXPR_BODY (to_return);
14940   if (condition)
14941     {
14942       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14943       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14944          The real EXIT_EXPR is one operand further. */
14945       EXPR_WFL_LINECOL (cnode) = location;
14946       /* This one is for accurate error reports */
14947       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14948       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14949     }
14950   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14951   POP_LOOP ();
14952   return to_return;
14953 }
14954
14955 /* Tailored version of finish_loop_body for FOR loops, when FOR
14956    loops feature the condition part */
14957
14958 static tree
14959 finish_for_loop (int location, tree condition, tree update, tree body)
14960 {
14961   /* Put the condition and the loop body in place */
14962   tree loop = finish_loop_body (location, condition, body, 0);
14963   /* LOOP is the current loop which has been now popped of the loop
14964      stack.  Mark the update block as reachable and install it.  We do
14965      this because the (current interpretation of the) JLS requires
14966      that the update expression be considered reachable even if the
14967      for loop's body doesn't complete normally.  */
14968   if (update != NULL_TREE && update != empty_stmt_node)
14969     {
14970       tree up2 = update;
14971       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
14972         up2 = EXPR_WFL_NODE (up2);
14973       /* It is possible for the update expression to be an
14974          EXPR_WFL_NODE wrapping nothing.  */
14975       if (up2 != NULL_TREE && up2 != empty_stmt_node)
14976         {
14977           /* Try to detect constraint violations.  These would be
14978              programming errors somewhere.  */
14979           if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
14980               || TREE_CODE (up2) == LOOP_EXPR)
14981             abort ();
14982           SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
14983         }
14984     }
14985   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
14986   return loop;
14987 }
14988
14989 /* Try to find the loop a block might be related to. This comprises
14990    the case where the LOOP_EXPR is found as the second operand of a
14991    COMPOUND_EXPR, because the loop happens to have an initialization
14992    part, then expressed as the first operand of the COMPOUND_EXPR. If
14993    the search finds something, 1 is returned. Otherwise, 0 is
14994    returned. The search is assumed to start from a
14995    LABELED_BLOCK_EXPR's block.  */
14996
14997 static tree
14998 search_loop (tree statement)
14999 {
15000   if (TREE_CODE (statement) == LOOP_EXPR)
15001     return statement;
15002
15003   if (TREE_CODE (statement) == BLOCK)
15004     statement = BLOCK_SUBBLOCKS (statement);
15005   else
15006     return NULL_TREE;
15007
15008   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15009     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15010       statement = TREE_OPERAND (statement, 1);
15011
15012   return (TREE_CODE (statement) == LOOP_EXPR
15013           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
15014 }
15015
15016 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15017    returned otherwise.  */
15018
15019 static int
15020 labeled_block_contains_loop_p (tree block, tree loop)
15021 {
15022   if (!block)
15023     return 0;
15024
15025   if (LABELED_BLOCK_BODY (block) == loop)
15026     return 1;
15027
15028   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
15029     return 1;
15030
15031   return 0;
15032 }
15033
15034 /* If the loop isn't surrounded by a labeled statement, create one and
15035    insert LOOP as its body.  */
15036
15037 static tree
15038 patch_loop_statement (tree loop)
15039 {
15040   tree loop_label;
15041
15042   TREE_TYPE (loop) = void_type_node;
15043   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
15044     return loop;
15045
15046   loop_label = build_labeled_block (0, NULL_TREE);
15047   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15048      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15049   LABELED_BLOCK_BODY (loop_label) = loop;
15050   PUSH_LABELED_BLOCK (loop_label);
15051   return loop_label;
15052 }
15053
15054 /* 14.13, 14.14: break and continue Statements */
15055
15056 /* Build a break or a continue statement. a null NAME indicates an
15057    unlabeled break/continue statement.  */
15058
15059 static tree
15060 build_bc_statement (int location, int is_break, tree name)
15061 {
15062   tree break_continue, label_block_expr = NULL_TREE;
15063
15064   if (name)
15065     {
15066       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15067             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15068         /* Null means that we don't have a target for this named
15069            break/continue. In this case, we make the target to be the
15070            label name, so that the error can be reported accurately in
15071            patch_bc_statement. */
15072         label_block_expr = EXPR_WFL_NODE (name);
15073     }
15074   /* Unlabeled break/continue will be handled during the
15075      break/continue patch operation */
15076   break_continue
15077     = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
15078
15079   IS_BREAK_STMT_P (break_continue) = is_break;
15080   TREE_SIDE_EFFECTS (break_continue) = 1;
15081   EXPR_WFL_LINECOL (break_continue) = location;
15082   break_continue = build_debugable_stmt (location, break_continue);
15083   return break_continue;
15084 }
15085
15086 /* Verification of a break/continue statement. */
15087
15088 static tree
15089 patch_bc_statement (tree node)
15090 {
15091   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15092   tree labeled_block = ctxp->current_labeled_block;
15093   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15094
15095   /* Having an identifier here means that the target is unknown. */
15096   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15097     {
15098       parse_error_context (wfl_operator, "No label definition found for `%s'",
15099                            IDENTIFIER_POINTER (bc_label));
15100       return error_mark_node;
15101     }
15102   if (! IS_BREAK_STMT_P (node))
15103     {
15104       /* It's a continue statement. */
15105       for (;; labeled_block = TREE_CHAIN (labeled_block))
15106         {
15107           if (labeled_block == NULL_TREE)
15108             {
15109               if (bc_label == NULL_TREE)
15110                 parse_error_context (wfl_operator,
15111                                      "`continue' must be in loop");
15112               else
15113                 parse_error_context
15114                   (wfl_operator, "continue label `%s' does not name a loop",
15115                    IDENTIFIER_POINTER (bc_label));
15116               return error_mark_node;
15117             }
15118           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15119                == continue_identifier_node)
15120               && (bc_label == NULL_TREE
15121                   || TREE_CHAIN (labeled_block) == bc_label))
15122             {
15123               bc_label = labeled_block;
15124               break;
15125             }
15126         }
15127     }
15128   else if (!bc_label)
15129     {
15130       for (;; labeled_block = TREE_CHAIN (labeled_block))
15131         {
15132           if (labeled_block == NULL_TREE)
15133             {
15134               parse_error_context (wfl_operator,
15135                                      "`break' must be in loop or switch");
15136               return error_mark_node;
15137             }
15138           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15139           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15140               || search_loop (target_stmt))
15141             {
15142               bc_label = labeled_block;
15143               break;
15144             }
15145         }
15146     }
15147
15148   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15149   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15150
15151   /* Our break/continue don't return values. */
15152   TREE_TYPE (node) = void_type_node;
15153   /* Encapsulate the break within a compound statement so that it's
15154      expanded all the times by expand_expr (and not clobbered
15155      sometimes, like after a if statement) */
15156   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15157   TREE_SIDE_EFFECTS (node) = 1;
15158   return node;
15159 }
15160
15161 /* Process the exit expression belonging to a loop. Its type must be
15162    boolean.  */
15163
15164 static tree
15165 patch_exit_expr (tree node)
15166 {
15167   tree expression = TREE_OPERAND (node, 0);
15168   TREE_TYPE (node) = error_mark_node;
15169   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15170
15171   /* The type of expression must be boolean */
15172   if (TREE_TYPE (expression) != boolean_type_node)
15173     {
15174       parse_error_context
15175         (wfl_operator,
15176     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15177          lang_printable_name (TREE_TYPE (expression), 0));
15178       return error_mark_node;
15179     }
15180   /* Now we know things are allright, invert the condition, fold and
15181      return */
15182   TREE_OPERAND (node, 0) =
15183     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15184
15185   if (! integer_zerop (TREE_OPERAND (node, 0))
15186       && ctxp->current_loop != NULL_TREE
15187       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15188     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15189   if (! integer_onep (TREE_OPERAND (node, 0)))
15190     CAN_COMPLETE_NORMALLY (node) = 1;
15191
15192
15193   TREE_TYPE (node) = void_type_node;
15194   return node;
15195 }
15196
15197 /* 14.9 Switch statement */
15198
15199 static tree
15200 patch_switch_statement (tree node)
15201 {
15202   tree se = TREE_OPERAND (node, 0), se_type;
15203   tree save, iter;
15204
15205   /* Complete the switch expression */
15206   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15207   se_type = TREE_TYPE (se);
15208   /* The type of the switch expression must be char, byte, short or
15209      int */
15210   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15211     {
15212       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15213       parse_error_context (wfl_operator,
15214           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15215                            lang_printable_name (se_type, 0));
15216       /* This is what java_complete_tree will check */
15217       TREE_OPERAND (node, 0) = error_mark_node;
15218       return error_mark_node;
15219     }
15220
15221   /* Save and restore the outer case label list.  */
15222   save = case_label_list;
15223   case_label_list = NULL_TREE;
15224
15225   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15226
15227   /* See if we've found a duplicate label.  We can't leave this until
15228      code generation, because in `--syntax-only' and `-C' modes we
15229      don't do ordinary code generation.  */
15230   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15231     {
15232       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15233       tree subiter;
15234       for (subiter = TREE_CHAIN (iter);
15235            subiter != NULL_TREE;
15236            subiter = TREE_CHAIN (subiter))
15237         {
15238           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15239           if (val == subval)
15240             {
15241               EXPR_WFL_LINECOL (wfl_operator)
15242                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15243               /* The case_label_list is in reverse order, so print the
15244                  outer label first.  */
15245               parse_error_context (wfl_operator, "duplicate case label: `"
15246                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15247               EXPR_WFL_LINECOL (wfl_operator)
15248                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15249               parse_error_context (wfl_operator, "original label is here");
15250
15251               break;
15252             }
15253         }
15254     }
15255
15256   case_label_list = save;
15257
15258   /* Ready to return */
15259   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15260     {
15261       TREE_TYPE (node) = error_mark_node;
15262       return error_mark_node;
15263     }
15264   TREE_TYPE (node) = void_type_node;
15265   TREE_SIDE_EFFECTS (node) = 1;
15266   CAN_COMPLETE_NORMALLY (node)
15267     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15268       || ! SWITCH_HAS_DEFAULT (node);
15269   return node;
15270 }
15271
15272 /* Assertions.  */
15273
15274 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15275    might be NULL_TREE.  */
15276 static tree
15277 build_assertion (int location, tree condition, tree value)
15278 {
15279   tree node;
15280   tree klass = GET_CPC ();
15281
15282   if (! CLASS_USES_ASSERTIONS (klass))
15283     {
15284       tree field, classdollar, id, call;
15285       tree class_type = TREE_TYPE (klass);
15286
15287       field = add_field (class_type,
15288                          get_identifier ("$assertionsDisabled"),
15289                          boolean_type_node,
15290                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15291       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15292       FIELD_SYNTHETIC (field) = 1;
15293
15294       if (!TYPE_DOT_CLASS (class_type))
15295         build_dot_class_method (class_type);
15296       classdollar = build_dot_class_method_invocation (class_type, class_type);
15297
15298       /* Call CLASS.desiredAssertionStatus().  */
15299       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15300       call = build (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15301       call = make_qualified_primary (classdollar, call, location);
15302       TREE_SIDE_EFFECTS (call) = 1;
15303
15304       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15305          seem odd, but we do it to generate code identical to that of
15306          the JDK.  */
15307       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15308       TREE_SIDE_EFFECTS (call) = 1;
15309       DECL_INITIAL (field) = call;
15310
15311       /* Record the initializer in the initializer statement list.  */
15312       call = build (MODIFY_EXPR, NULL_TREE, field, call);
15313       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15314       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15315       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15316
15317       CLASS_USES_ASSERTIONS (klass) = 1;
15318     }
15319
15320   if (value != NULL_TREE)
15321     value = tree_cons (NULL_TREE, value, NULL_TREE);
15322
15323   node = build_wfl_node (get_identifier ("java"));
15324   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15325                               location);
15326   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15327                               location);
15328
15329   node = build (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15330   TREE_SIDE_EFFECTS (node) = 1;
15331   /* It is too early to use BUILD_THROW.  */
15332   node = build1 (THROW_EXPR, NULL_TREE, node);
15333   TREE_SIDE_EFFECTS (node) = 1;
15334
15335   /* We invert the condition; if we just put NODE as the `else' part
15336      then we generate weird-looking bytecode.  */
15337   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15338   /* Check $assertionsDisabled.  */
15339   condition
15340     = build (TRUTH_ANDIF_EXPR, NULL_TREE,
15341              build1 (TRUTH_NOT_EXPR, NULL_TREE,
15342                      build_wfl_node (get_identifier ("$assertionsDisabled"))),
15343              condition);
15344   node = build_if_else_statement (location, condition, node, NULL_TREE);
15345   return node;
15346 }
15347
15348 /* 14.18 The try/catch statements */
15349
15350 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15351    catches TYPE and executes CATCH_STMTS.  */
15352
15353 static tree
15354 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15355                             tree catch_stmts)
15356 {
15357   tree try_block, catch_clause_param, catch_block, catch;
15358
15359   /* First build a try block */
15360   try_block = build_expr_block (try_stmts, NULL_TREE);
15361
15362   /* Build a catch block: we need a catch clause parameter */
15363   if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15364     {
15365       tree catch_type = obtain_incomplete_type (type_or_name);
15366       jdep *dep;
15367       catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15368       register_incomplete_type (JDEP_VARIABLE, type_or_name,
15369                                 catch_clause_param, catch_type);
15370       dep = CLASSD_LAST (ctxp->classd_list);
15371       JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15372     }
15373   else
15374     catch_clause_param = build_decl (VAR_DECL, wpv_id,
15375                                      build_pointer_type (type_or_name));
15376
15377   /* And a block */
15378   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15379
15380   /* Initialize the variable and store in the block */
15381   catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15382                  build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15383   add_stmt_to_block (catch_block, NULL_TREE, catch);
15384
15385   /* Add the catch statements */
15386   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15387
15388   /* Now we can build a CATCH_EXPR */
15389   catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
15390
15391   return build_try_statement (location, try_block, catch_block);
15392 }
15393
15394 static tree
15395 build_try_statement (int location, tree try_block, tree catches)
15396 {
15397   tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
15398   EXPR_WFL_LINECOL (node) = location;
15399   return node;
15400 }
15401
15402 static tree
15403 build_try_finally_statement (int location, tree try_block, tree finally)
15404 {
15405   tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15406   EXPR_WFL_LINECOL (node) = location;
15407   return node;
15408 }
15409
15410 static tree
15411 patch_try_statement (tree node)
15412 {
15413   int error_found = 0;
15414   tree try = TREE_OPERAND (node, 0);
15415   /* Exception handlers are considered in left to right order */
15416   tree catch = nreverse (TREE_OPERAND (node, 1));
15417   tree current, caught_type_list = NULL_TREE;
15418
15419   /* Check catch clauses, if any. Every time we find an error, we try
15420      to process the next catch clause. We process the catch clause before
15421      the try block so that when processing the try block we can check thrown
15422      exceptions againts the caught type list. */
15423   for (current = catch; current; current = TREE_CHAIN (current))
15424     {
15425       tree carg_decl, carg_type;
15426       tree sub_current, catch_block, catch_clause;
15427       int unreachable;
15428
15429       /* At this point, the structure of the catch clause is
15430            CATCH_EXPR           (catch node)
15431              BLOCK              (with the decl of the parameter)
15432                COMPOUND_EXPR
15433                  MODIFY_EXPR   (assignment of the catch parameter)
15434                  BLOCK          (catch clause block)
15435        */
15436       catch_clause = TREE_OPERAND (current, 0);
15437       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15438       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15439
15440       /* Catch clauses can't have more than one parameter declared,
15441          but it's already enforced by the grammar. Make sure that the
15442          only parameter of the clause statement in of class Throwable
15443          or a subclass of Throwable, but that was done earlier. The
15444          catch clause parameter type has also been resolved. */
15445
15446       /* Just make sure that the catch clause parameter type inherits
15447          from java.lang.Throwable */
15448       if (!inherits_from_p (carg_type, throwable_type_node))
15449         {
15450           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15451           parse_error_context (wfl_operator,
15452                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15453                                lang_printable_name (carg_type, 0));
15454           error_found = 1;
15455           continue;
15456         }
15457
15458       /* Partial check for unreachable catch statement: The catch
15459          clause is reachable iff is no earlier catch block A in
15460          the try statement such that the type of the catch
15461          clause's parameter is the same as or a subclass of the
15462          type of A's parameter */
15463       unreachable = 0;
15464       for (sub_current = catch;
15465            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15466         {
15467           tree sub_catch_clause, decl;
15468           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15469           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15470
15471           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15472             {
15473               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15474               parse_error_context
15475                 (wfl_operator,
15476                  "`catch' not reached because of the catch clause at line %d",
15477                  EXPR_WFL_LINENO (sub_current));
15478               unreachable = error_found = 1;
15479               break;
15480             }
15481         }
15482       /* Complete the catch clause block */
15483       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15484       if (catch_block == error_mark_node)
15485         {
15486           error_found = 1;
15487           continue;
15488         }
15489       if (CAN_COMPLETE_NORMALLY (catch_block))
15490         CAN_COMPLETE_NORMALLY (node) = 1;
15491       TREE_OPERAND (current, 0) = catch_block;
15492
15493       if (unreachable)
15494         continue;
15495
15496       /* Things to do here: the exception must be thrown */
15497
15498       /* Link this type to the caught type list */
15499       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15500     }
15501
15502   PUSH_EXCEPTIONS (caught_type_list);
15503   if ((try = java_complete_tree (try)) == error_mark_node)
15504     error_found = 1;
15505   if (CAN_COMPLETE_NORMALLY (try))
15506     CAN_COMPLETE_NORMALLY (node) = 1;
15507   POP_EXCEPTIONS ();
15508
15509   /* Verification ends here */
15510   if (error_found)
15511     return error_mark_node;
15512
15513   TREE_OPERAND (node, 0) = try;
15514   TREE_OPERAND (node, 1) = catch;
15515   TREE_TYPE (node) = void_type_node;
15516   return node;
15517 }
15518
15519 /* 14.17 The synchronized Statement */
15520
15521 static tree
15522 patch_synchronized_statement (tree node, tree wfl_op1)
15523 {
15524   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15525   tree block = TREE_OPERAND (node, 1);
15526
15527   tree tmp, enter, exit, expr_decl, assignment;
15528
15529   if (expr == error_mark_node)
15530     {
15531       block = java_complete_tree (block);
15532       return expr;
15533     }
15534
15535   /* We might be trying to synchronize on a STRING_CST */
15536   if ((tmp = patch_string (expr)))
15537     expr = tmp;
15538
15539   /* The TYPE of expr must be a reference type */
15540   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15541     {
15542       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15543       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15544                            lang_printable_name (TREE_TYPE (expr), 0));
15545       return error_mark_node;
15546     }
15547
15548   if (flag_emit_xref)
15549     {
15550       TREE_OPERAND (node, 0) = expr;
15551       TREE_OPERAND (node, 1) = java_complete_tree (block);
15552       CAN_COMPLETE_NORMALLY (node) = 1;
15553       return node;
15554     }
15555
15556   /* Generate a try-finally for the synchronized statement, except
15557      that the handler that catches all throw exception calls
15558      _Jv_MonitorExit and then rethrow the exception.
15559      The synchronized statement is then implemented as:
15560      TRY
15561        {
15562          _Jv_MonitorEnter (expression)
15563          synchronized_block
15564          _Jv_MonitorExit (expression)
15565        }
15566      CATCH_ALL
15567        {
15568          e = _Jv_exception_info ();
15569          _Jv_MonitorExit (expression)
15570          Throw (e);
15571        } */
15572
15573   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15574   BUILD_MONITOR_ENTER (enter, expr_decl);
15575   BUILD_MONITOR_EXIT (exit, expr_decl);
15576   CAN_COMPLETE_NORMALLY (enter) = 1;
15577   CAN_COMPLETE_NORMALLY (exit) = 1;
15578   assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15579   TREE_SIDE_EFFECTS (assignment) = 1;
15580   node = build (COMPOUND_EXPR, NULL_TREE,
15581                 build (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15582                 build (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15583   node = build_expr_block (node, expr_decl);
15584
15585   return java_complete_tree (node);
15586 }
15587
15588 /* 14.16 The throw Statement */
15589
15590 static tree
15591 patch_throw_statement (tree node, tree wfl_op1)
15592 {
15593   tree expr = TREE_OPERAND (node, 0);
15594   tree type = TREE_TYPE (expr);
15595   int unchecked_ok = 0, tryblock_throws_ok = 0;
15596
15597   /* Thrown expression must be assignable to java.lang.Throwable */
15598   if (!try_reference_assignconv (throwable_type_node, expr))
15599     {
15600       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15601       parse_error_context (wfl_operator,
15602     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15603                            lang_printable_name (type, 0));
15604       /* If the thrown expression was a reference, we further the
15605          compile-time check. */
15606       if (!JREFERENCE_TYPE_P (type))
15607         return error_mark_node;
15608     }
15609
15610   /* At least one of the following must be true */
15611
15612   /* The type of the throw expression is a not checked exception,
15613      i.e. is a unchecked expression. */
15614   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15615
15616   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15617   /* An instance can't throw a checked exception unless that exception
15618      is explicitly declared in the `throws' clause of each
15619      constructor. This doesn't apply to anonymous classes, since they
15620      don't have declared constructors. */
15621   if (!unchecked_ok
15622       && DECL_INSTINIT_P (current_function_decl)
15623       && !ANONYMOUS_CLASS_P (current_class))
15624     {
15625       tree current;
15626       for (current = TYPE_METHODS (current_class); current;
15627            current = TREE_CHAIN (current))
15628         if (DECL_CONSTRUCTOR_P (current)
15629             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15630           {
15631             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)",
15632                                  lang_printable_name (TREE_TYPE (expr), 0));
15633             return error_mark_node;
15634           }
15635     }
15636
15637   /* Throw is contained in a try statement and at least one catch
15638      clause can receive the thrown expression or the current method is
15639      declared to throw such an exception. Or, the throw statement is
15640      contained in a method or constructor declaration and the type of
15641      the Expression is assignable to at least one type listed in the
15642      throws clause the declaration. */
15643   if (!unchecked_ok)
15644     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15645   if (!(unchecked_ok || tryblock_throws_ok))
15646     {
15647       /* If there is a surrounding try block that has no matching
15648          clatch clause, report it first. A surrounding try block exits
15649          only if there is something after the list of checked
15650          exception thrown by the current function (if any). */
15651       if (IN_TRY_BLOCK_P ())
15652         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15653                              lang_printable_name (type, 0));
15654       /* If we have no surrounding try statement and the method doesn't have
15655          any throws, report it now. FIXME */
15656
15657       /* We report that the exception can't be throw from a try block
15658          in all circumstances but when the `throw' is inside a static
15659          block. */
15660       else if (!EXCEPTIONS_P (currently_caught_type_list)
15661                && !tryblock_throws_ok)
15662         {
15663           if (DECL_CLINIT_P (current_function_decl))
15664             parse_error_context (wfl_operator,
15665                    "Checked exception `%s' can't be thrown in initializer",
15666                                  lang_printable_name (type, 0));
15667           else
15668             parse_error_context (wfl_operator,
15669                    "Checked exception `%s' isn't thrown from a `try' block",
15670                                  lang_printable_name (type, 0));
15671         }
15672       /* Otherwise, the current method doesn't have the appropriate
15673          throws declaration */
15674       else
15675         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15676                              lang_printable_name (type, 0));
15677       return error_mark_node;
15678     }
15679
15680   if (! flag_emit_class_files && ! flag_emit_xref)
15681     BUILD_THROW (node, expr);
15682
15683   /* If doing xrefs, keep the location where the `throw' was seen. */
15684   if (flag_emit_xref)
15685     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15686   return node;
15687 }
15688
15689 /* Check that exception said to be thrown by method DECL can be
15690    effectively caught from where DECL is invoked.  THIS_EXPR is the
15691    expression that computes `this' for the method call.  */
15692 static void
15693 check_thrown_exceptions (int location, tree decl, tree this_expr)
15694 {
15695   tree throws;
15696   int is_array_call = 0;
15697
15698   /* Skip check within generated methods, such as access$<n>.  */
15699   if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
15700     return;
15701
15702   if (this_expr != NULL_TREE
15703       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15704       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15705     is_array_call = 1;
15706
15707   /* For all the unchecked exceptions thrown by DECL.  */
15708   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15709        throws = TREE_CHAIN (throws))
15710     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15711       {
15712         /* Suppress errors about cloning arrays.  */
15713         if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15714           continue;
15715
15716         EXPR_WFL_LINECOL (wfl_operator) = location;
15717         if (DECL_FINIT_P (current_function_decl))
15718           parse_error_context
15719             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15720              lang_printable_name (TREE_VALUE (throws), 0));
15721         else
15722           {
15723             parse_error_context
15724               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15725                lang_printable_name (TREE_VALUE (throws), 0),
15726                (DECL_INIT_P (current_function_decl) ?
15727                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15728                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15729           }
15730       }
15731 }
15732
15733 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15734    try-catch blocks, OR is listed in the `throws' clause of the
15735    current method.  */
15736
15737 static int
15738 check_thrown_exceptions_do (tree exception)
15739 {
15740   tree list = currently_caught_type_list;
15741   resolve_and_layout (exception, NULL_TREE);
15742   /* First, all the nested try-catch-finally at that stage. The
15743      last element contains `throws' clause exceptions, if any. */
15744   if (IS_UNCHECKED_EXCEPTION_P (exception))
15745     return 1;
15746   while (list)
15747     {
15748       tree caught;
15749       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15750         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15751           return 1;
15752       list = TREE_CHAIN (list);
15753     }
15754   return 0;
15755 }
15756
15757 static void
15758 purge_unchecked_exceptions (tree mdecl)
15759 {
15760   tree throws = DECL_FUNCTION_THROWS (mdecl);
15761   tree new = NULL_TREE;
15762
15763   while (throws)
15764     {
15765       tree next = TREE_CHAIN (throws);
15766       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15767         {
15768           TREE_CHAIN (throws) = new;
15769           new = throws;
15770         }
15771       throws = next;
15772     }
15773   /* List is inverted here, but it doesn't matter */
15774   DECL_FUNCTION_THROWS (mdecl) = new;
15775 }
15776
15777 /* This function goes over all of CLASS_TYPE ctors and checks whether
15778    each of them features at least one unchecked exception in its
15779    `throws' clause. If it's the case, it returns `true', `false'
15780    otherwise.  */
15781
15782 static bool
15783 ctors_unchecked_throws_clause_p (tree class_type)
15784 {
15785   tree current;
15786
15787   for (current = TYPE_METHODS (class_type); current;
15788        current = TREE_CHAIN (current))
15789     {
15790       bool ctu = false; /* Ctor Throws Unchecked */
15791       if (DECL_CONSTRUCTOR_P (current))
15792         {
15793           tree throws;
15794           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15795                throws = TREE_CHAIN (throws))
15796             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15797               ctu = true;
15798         }
15799       /* We return false as we found one ctor that is unfit. */
15800       if (!ctu && DECL_CONSTRUCTOR_P (current))
15801         return false;
15802     }
15803   /* All ctors feature at least one unchecked exception in their
15804      `throws' clause. */
15805   return true;
15806 }
15807
15808 /* 15.24 Conditional Operator ?: */
15809
15810 static tree
15811 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15812 {
15813   tree cond = TREE_OPERAND (node, 0);
15814   tree op1 = TREE_OPERAND (node, 1);
15815   tree op2 = TREE_OPERAND (node, 2);
15816   tree resulting_type = NULL_TREE;
15817   tree t1, t2, patched;
15818   int error_found = 0;
15819
15820   /* Operands of ?: might be StringBuffers crafted as a result of a
15821      string concatenation. Obtain a descent operand here.  */
15822   if ((patched = patch_string (op1)))
15823     TREE_OPERAND (node, 1) = op1 = patched;
15824   if ((patched = patch_string (op2)))
15825     TREE_OPERAND (node, 2) = op2 = patched;
15826
15827   t1 = TREE_TYPE (op1);
15828   t2 = TREE_TYPE (op2);
15829
15830   /* The first expression must be a boolean */
15831   if (TREE_TYPE (cond) != boolean_type_node)
15832     {
15833       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15834       parse_error_context (wfl_operator,
15835                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15836                            lang_printable_name (TREE_TYPE (cond), 0));
15837       error_found = 1;
15838     }
15839
15840   /* Second and third can be numeric, boolean (i.e. primitive),
15841      references or null. Anything else results in an error */
15842   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15843         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15844             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15845         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15846     error_found = 1;
15847
15848   /* Determine the type of the conditional expression. Same types are
15849      easy to deal with */
15850   else if (t1 == t2)
15851     resulting_type = t1;
15852
15853   /* There are different rules for numeric types */
15854   else if (JNUMERIC_TYPE_P (t1))
15855     {
15856       /* if byte/short found, the resulting type is short */
15857       if ((t1 == byte_type_node && t2 == short_type_node)
15858           || (t1 == short_type_node && t2 == byte_type_node))
15859         resulting_type = short_type_node;
15860
15861       /* If t1 is a constant int and t2 is of type byte, short or char
15862          and t1's value fits in t2, then the resulting type is t2 */
15863       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15864           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15865         resulting_type = t2;
15866
15867       /* If t2 is a constant int and t1 is of type byte, short or char
15868          and t2's value fits in t1, then the resulting type is t1 */
15869       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15870           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15871         resulting_type = t1;
15872
15873       /* Otherwise, binary numeric promotion is applied and the
15874          resulting type is the promoted type of operand 1 and 2 */
15875       else
15876         resulting_type = binary_numeric_promotion (t1, t2,
15877                                                    &TREE_OPERAND (node, 1),
15878                                                    &TREE_OPERAND (node, 2));
15879     }
15880
15881   /* Cases of a reference and a null type */
15882   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15883     resulting_type = t1;
15884
15885   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15886     resulting_type = t2;
15887
15888   /* Last case: different reference types. If a type can be converted
15889      into the other one by assignment conversion, the latter
15890      determines the type of the expression */
15891   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15892     resulting_type = promote_type (t1);
15893
15894   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15895     resulting_type = promote_type (t2);
15896
15897   /* If we don't have any resulting type, we're in trouble */
15898   if (!resulting_type)
15899     {
15900       char *t = xstrdup (lang_printable_name (t1, 0));
15901       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15902       parse_error_context (wfl_operator,
15903                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15904                            t, lang_printable_name (t2, 0));
15905       free (t);
15906       error_found = 1;
15907     }
15908
15909   if (error_found)
15910     {
15911       TREE_TYPE (node) = error_mark_node;
15912       return error_mark_node;
15913     }
15914
15915   TREE_TYPE (node) = resulting_type;
15916   TREE_SET_CODE (node, COND_EXPR);
15917   CAN_COMPLETE_NORMALLY (node) = 1;
15918   return node;
15919 }
15920
15921 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15922
15923 static tree
15924 maybe_build_class_init_for_field (tree decl, tree expr)
15925 {
15926   tree clas = DECL_CONTEXT (decl);
15927   if (flag_emit_class_files || flag_emit_xref)
15928     return expr;
15929
15930   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
15931       && FIELD_FINAL (decl))
15932     {
15933       tree init = DECL_INITIAL (decl);
15934       if (init != NULL_TREE)
15935         init = fold_constant_for_init (init, decl);
15936       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
15937         return expr;
15938     }
15939
15940   return build_class_init (clas, expr);
15941 }
15942
15943 /* Try to constant fold NODE.
15944    If NODE is not a constant expression, return NULL_EXPR.
15945    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15946
15947 static tree
15948 fold_constant_for_init (tree node, tree context)
15949 {
15950   tree op0, op1, val;
15951   enum tree_code code = TREE_CODE (node);
15952
15953   switch (code)
15954     {
15955     case INTEGER_CST:
15956       if (node == null_pointer_node)
15957         return NULL_TREE;
15958     case STRING_CST:
15959     case REAL_CST:
15960       return node;
15961
15962     case PLUS_EXPR:
15963     case MINUS_EXPR:
15964     case MULT_EXPR:
15965     case TRUNC_MOD_EXPR:
15966     case RDIV_EXPR:
15967     case LSHIFT_EXPR:
15968     case RSHIFT_EXPR:
15969     case URSHIFT_EXPR:
15970     case BIT_AND_EXPR:
15971     case BIT_XOR_EXPR:
15972     case BIT_IOR_EXPR:
15973     case TRUTH_ANDIF_EXPR:
15974     case TRUTH_ORIF_EXPR:
15975     case EQ_EXPR:
15976     case NE_EXPR:
15977     case GT_EXPR:
15978     case GE_EXPR:
15979     case LT_EXPR:
15980     case LE_EXPR:
15981       op0 = TREE_OPERAND (node, 0);
15982       op1 = TREE_OPERAND (node, 1);
15983       val = fold_constant_for_init (op0, context);
15984       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15985         return NULL_TREE;
15986       TREE_OPERAND (node, 0) = val;
15987       val = fold_constant_for_init (op1, context);
15988       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15989         return NULL_TREE;
15990       TREE_OPERAND (node, 1) = val;
15991       return patch_binop (node, op0, op1);
15992
15993     case UNARY_PLUS_EXPR:
15994     case NEGATE_EXPR:
15995     case TRUTH_NOT_EXPR:
15996     case BIT_NOT_EXPR:
15997     case CONVERT_EXPR:
15998       op0 = TREE_OPERAND (node, 0);
15999       val = fold_constant_for_init (op0, context);
16000       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16001         return NULL_TREE;
16002       TREE_OPERAND (node, 0) = val;
16003       val = patch_unaryop (node, op0);
16004       if (! TREE_CONSTANT (val))
16005         return NULL_TREE;
16006       return val;
16007
16008       break;
16009
16010     case COND_EXPR:
16011       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
16012       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16013         return NULL_TREE;
16014       TREE_OPERAND (node, 0) = val;
16015       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
16016       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16017         return NULL_TREE;
16018       TREE_OPERAND (node, 1) = val;
16019       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
16020       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16021         return NULL_TREE;
16022       TREE_OPERAND (node, 2) = val;
16023       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
16024         : TREE_OPERAND (node, 2);
16025
16026     case VAR_DECL:
16027     case FIELD_DECL:
16028       if (! FIELD_FINAL (node)
16029           || DECL_INITIAL (node) == NULL_TREE)
16030         return NULL_TREE;
16031       val = DECL_INITIAL (node);
16032       /* Guard against infinite recursion. */
16033       DECL_INITIAL (node) = NULL_TREE;
16034       val = fold_constant_for_init (val, node);
16035       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
16036         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
16037       DECL_INITIAL (node) = val;
16038       return val;
16039
16040     case EXPR_WITH_FILE_LOCATION:
16041       /* Compare java_complete_tree and resolve_expression_name. */
16042       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
16043           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
16044         {
16045           tree name = EXPR_WFL_NODE (node);
16046           tree decl;
16047           if (PRIMARY_P (node))
16048             return NULL_TREE;
16049           else if (! QUALIFIED_P (name))
16050             {
16051               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
16052               if (decl == NULL_TREE
16053                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16054                 return NULL_TREE;
16055               return fold_constant_for_init (decl, decl);
16056             }
16057           else
16058             {
16059               /* Install the proper context for the field resolution.
16060                  The prior context is restored once the name is
16061                  properly qualified. */
16062               tree saved_current_class = current_class;
16063               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
16064               current_class = DECL_CONTEXT (context);
16065               qualify_ambiguous_name (node);
16066               current_class = saved_current_class;
16067               if (resolve_field_access (node, &decl, NULL)
16068                   && decl != NULL_TREE)
16069                 return fold_constant_for_init (decl, decl);
16070               return NULL_TREE;
16071             }
16072         }
16073       else
16074         {
16075           op0 = TREE_OPERAND (node, 0);
16076           val = fold_constant_for_init (op0, context);
16077           if (val == NULL_TREE || ! TREE_CONSTANT (val))
16078             return NULL_TREE;
16079           TREE_OPERAND (node, 0) = val;
16080           return val;
16081         }
16082
16083 #ifdef USE_COMPONENT_REF
16084     case IDENTIFIER:
16085     case COMPONENT_REF:
16086       ?;
16087 #endif
16088
16089     default:
16090       return NULL_TREE;
16091     }
16092 }
16093
16094 #ifdef USE_COMPONENT_REF
16095 /* Context is 'T' for TypeName, 'P' for PackageName,
16096    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16097
16098 tree
16099 resolve_simple_name (tree name, int context)
16100 {
16101 }
16102
16103 tree
16104 resolve_qualified_name (tree name, int context)
16105 {
16106 }
16107 #endif
16108
16109 void
16110 init_src_parse (void)
16111 {
16112   /* Sanity check; we've been bit by this before.  */
16113   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16114     abort ();
16115 }
16116
16117 \f
16118
16119 /* This section deals with the functions that are called when tables
16120    recording class initialization information are traversed.  */
16121
16122 /* Attach to PTR (a block) the declaration found in ENTRY. */
16123
16124 static int
16125 attach_init_test_initialization_flags (void **entry, void *ptr)
16126 {
16127   tree block = (tree)ptr;
16128   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16129
16130   if (block != error_mark_node)
16131     {
16132       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16133       BLOCK_EXPR_DECLS (block) = ite->value;
16134     }
16135   return true;
16136 }
16137
16138 /* This function is called for each class that is known definitely
16139    initialized when a given static method was called. This function
16140    augments a compound expression (INFO) storing all assignment to
16141    initialized static class flags if a flag already existed, otherwise
16142    a new one is created.  */
16143
16144 static int
16145 emit_test_initialization (void **entry_p, void *info)
16146 {
16147   tree l = (tree) info;
16148   tree decl, init;
16149   tree key = (tree) *entry_p;
16150   tree *ite;
16151   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16152
16153   /* If we haven't found a flag and we're dealing with self registered
16154      with current_function_decl, then don't do anything. Self is
16155      always added as definitely initialized but this information is
16156      valid only if used outside the current function. */
16157   if (current_function_decl == TREE_PURPOSE (l)
16158       && java_treetreehash_find (cf_ht, key) == NULL)
16159     return true;
16160
16161   ite = java_treetreehash_new (cf_ht, key);
16162
16163   /* If we don't have a variable, create one and install it. */
16164   if (*ite == NULL)
16165     {
16166       tree block;
16167
16168       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16169       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16170       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16171       DECL_CONTEXT (decl) = current_function_decl;
16172       DECL_INITIAL (decl) = boolean_true_node;
16173       /* Don't emit any symbolic debugging info for this decl.  */
16174       DECL_IGNORED_P (decl) = 1;
16175
16176       /* The trick is to find the right context for it. */
16177       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16178       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16179       BLOCK_EXPR_DECLS (block) = decl;
16180       *ite = decl;
16181     }
16182   else
16183     decl = *ite;
16184
16185   /* Now simply augment the compound that holds all the assignments
16186      pertaining to this method invocation. */
16187   init = build (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16188   TREE_SIDE_EFFECTS (init) = 1;
16189   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16190   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16191
16192   return true;
16193 }
16194
16195 #include "gt-java-parse.h"
16196 #include "gtype-java.h"