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
   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 tree find_expr_with_wfl (tree);
 254 static void missing_return_error (tree);
 255 static tree build_new_array_init (int, tree);
 256 static tree patch_new_array_init (tree, tree);
 257 static tree maybe_build_array_element_wfl (tree);
 258 static int array_constructor_check_entry (tree, tree);
 259 static const char *purify_type_name (const char *);
 260 static tree fold_constant_for_init (tree, tree);
 261 static tree strip_out_static_field_access_decl (tree);
 262 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
 263 static void static_ref_err (tree, tree, tree);
 264 static void parser_add_interface (tree, tree, tree);
 265 static void add_superinterfaces (tree, tree);
 266 static tree jdep_resolve_class (jdep *);
 267 static int note_possible_classname (const char *, int);
 268 static void java_complete_expand_classes (void);
 269 static void java_complete_expand_class (tree);
 270 static void java_complete_expand_methods (tree);
 271 static tree cut_identifier_in_qualified (tree);
 272 static tree java_stabilize_reference (tree);
 273 static tree do_unary_numeric_promotion (tree);
 274 static char * operator_string (tree);
 275 static tree do_merge_string_cste (tree, const char *, int, int);
 276 static tree merge_string_cste (tree, tree, int);
 277 static tree java_refold (tree);
 278 static int java_decl_equiv (tree, tree);
 279 static int binop_compound_p (enum tree_code);
 280 static tree search_loop (tree);
 281 static int labeled_block_contains_loop_p (tree, tree);
 282 static int check_abstract_method_definitions (int, tree, tree);
 283 static void java_check_abstract_method_definitions (tree);
 284 static void java_debug_context_do (int);
 285 static void java_parser_context_push_initialized_field (void);
 286 static void java_parser_context_pop_initialized_field (void);
 287 static tree reorder_static_initialized (tree);
 288 static void java_parser_context_suspend (void);
 289 static void java_parser_context_resume (void);
 290 static int pop_current_osb (struct parser_ctxt *);
 291
 292 /* JDK 1.1 work. FIXME */
 293
 294 static tree maybe_make_nested_class_name (tree);
 295 static int make_nested_class_name (tree);
 296 static void set_nested_class_simple_name_value (tree, int);
 297 static void link_nested_class_to_enclosing (void);
 298 static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
 299 static tree find_as_inner_class (tree, tree, tree);
 300 static tree find_as_inner_class_do (tree, tree);
 301 static int check_inner_class_redefinition (tree, tree);
 302
 303 static tree build_thisn_assign (void);
 304 static tree build_current_thisn (tree);
 305 static tree build_access_to_thisn (tree, tree, int);
 306 static tree maybe_build_thisn_access_method (tree);
 307
 308 static tree build_outer_field_access (tree, tree);
 309 static tree build_outer_field_access_methods (tree);
 310 static tree build_outer_field_access_expr (int, tree, tree,
 311                                                   tree, tree);
 312 static tree build_outer_method_access_method (tree);
 313 static tree build_new_access_id (void);
 314 static tree build_outer_field_access_method (tree, tree, tree,
 315                                                     tree, tree);
 316
 317 static int outer_field_access_p (tree, tree);
 318 static int outer_field_expanded_access_p (tree, tree *,
 319                                                  tree *, tree *);
 320 static tree outer_field_access_fix (tree, tree, tree);
 321 static tree build_incomplete_class_ref (int, tree);
 322 static tree patch_incomplete_class_ref (tree);
 323 static tree create_anonymous_class (int, tree);
 324 static void patch_anonymous_class (tree, tree, tree);
 325 static void add_inner_class_fields (tree, tree);
 326
 327 static tree build_dot_class_method (tree);
 328 static tree build_dot_class_method_invocation (tree);
 329 static void create_new_parser_context (int);
 330 static tree maybe_build_class_init_for_field (tree, tree);
 331
 332 static int attach_init_test_initialization_flags (void **, void *);
 333 static int emit_test_initialization (void **, void *);
 334
 335 static char *string_convert_int_cst (tree);
 336
 337 /* Number of error found so far. */
 338 int java_error_count;
 339 /* Number of warning found so far. */
 340 int java_warning_count;
 341 /* Tell when not to fold, when doing xrefs */
 342 int do_not_fold;
 343 /* Cyclic inheritance report, as it can be set by layout_class */
 344 const char *cyclic_inheritance_report;
 345
 346 /* The current parser context */
 347 struct parser_ctxt *ctxp;
 348
 349 /* List of things that were analyzed for which code will be generated */
 350 struct parser_ctxt *ctxp_for_generation = NULL;
 351
 352 /* binop_lookup maps token to tree_code. It is used where binary
 353    operations are involved and required by the parser. RDIV_EXPR
 354    covers both integral/floating point division. The code is changed
 355    once the type of both operator is worked out.  */
 356
 357 static const enum tree_code binop_lookup[19] =
 358   {
 359     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
 360     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
 361     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
 362     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
 363     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
 364    };
 365 #define BINOP_LOOKUP(VALUE)                                             \
 366   binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
 367
 368 /* This is the end index for binary operators that can also be used
 369    in compound assignements. */
 370 #define BINOP_COMPOUND_CANDIDATES 11
 371
 372 /* The "$L" identifier we use to create labels.  */
 373 static GTY(()) tree label_id;
 374
 375 /* The "StringBuffer" identifier used for the String `+' operator. */
 376 static GTY(()) tree wfl_string_buffer;
 377
 378 /* The "append" identifier used for String `+' operator.  */
 379 static GTY(()) tree wfl_append;
 380
 381 /* The "toString" identifier used for String `+' operator. */
 382 static GTY(()) tree wfl_to_string;
 383
 384 /* The "java.lang" import qualified name.  */
 385 static GTY(()) tree java_lang_id;
 386
 387 /* The generated `inst$' identifier used for generated enclosing
 388    instance/field access functions.  */
 389 static GTY(()) tree inst_id;
 390
 391 /* Context and flag for static blocks */
 392 static GTY(()) tree current_static_block;
 393
 394 /* The generated `write_parm_value$' identifier.  */
 395 static GTY(()) tree wpv_id;
 396
 397 /* The list of all packages we've seen so far */
 398 static GTY(()) tree package_list;
 399
 400 /* Hold THIS for the scope of the current method decl.  */
 401 static GTY(()) tree current_this;
 402
 403 /* Hold a list of catch clauses list. The first element of this list is
 404    the list of the catch clauses of the currently analysed try block. */
 405 static GTY(()) tree currently_caught_type_list;
 406
 407 /* This holds a linked list of all the case labels for the current
 408    switch statement.  It is only used when checking to see if there
 409    are duplicate labels.  FIXME: probably this should just be attached
 410    to the switch itself; then it could be referenced via
 411    `ctxp->current_loop'.  */
 412 static GTY(()) tree case_label_list;
 413
 414 /* Anonymous class counter. Will be reset to 1 every time a non
 415    anonymous class gets created. */
 416 static int anonymous_class_counter = 1;
 417
 418 static GTY(()) tree src_parse_roots[1];
 419
 420 /* All classes seen from source code */
 421 #define gclass_list src_parse_roots[0]
 422
 423 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
 424    line and point it out.  */
 425 /* Should point out the one that don't fit. ASCII/unicode, going
 426    backward. FIXME */
 427
 428 #define check_modifiers(__message, __value, __mask) do {        \
 429   if ((__value) & ~(__mask))                                    \
 430     {                                                           \
 431       size_t i, remainder = (__value) & ~(__mask);              \
 432       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)     \
 433         if ((1 << i) & remainder)                               \
 434           parse_error_context (ctxp->modifier_ctx [i], (__message), \
 435                                java_accstring_lookup (1 << i)); \
 436     }                                                           \
 437 } while (0)
 438
 439 %}
 440
 441 %union {
 442   tree node;
 443   int sub_token;
 444   struct {
 445     int token;
 446     int location;
 447   } operator;
 448   int value;
 449 }
 450
 451 %{
 452 #include "lex.c"
 453 %}
 454
 455 %pure_parser
 456
 457 /* Things defined here have to match the order of what's in the
 458    binop_lookup table.  */
 459
 460 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
 461 %token   LS_TK           SRS_TK          ZRS_TK
 462 %token   AND_TK          XOR_TK          OR_TK
 463 %token   BOOL_AND_TK BOOL_OR_TK
 464 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
 465
 466 /* This maps to the same binop_lookup entry than the token above */
 467
 468 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
 469 %token   REM_ASSIGN_TK
 470 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 471 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
 472
 473
 474 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
 475
 476 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
 477 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
 478 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
 479 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
 480 %token   MODIFIER_TK
 481
 482 /* Keep those two in order, too */
 483 %token   DECR_TK INCR_TK
 484
 485 /* From now one, things can be in any order */
 486
 487 %token   DEFAULT_TK      IF_TK              THROW_TK
 488 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
 489 %token   THROWS_TK       BREAK_TK           IMPORT_TK
 490 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
 491 %token   VOID_TK         CATCH_TK           INTERFACE_TK
 492 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
 493 %token   SUPER_TK        WHILE_TK           CLASS_TK
 494 %token   SWITCH_TK       CONST_TK           TRY_TK
 495 %token   FOR_TK          NEW_TK             CONTINUE_TK
 496 %token   GOTO_TK         PACKAGE_TK         THIS_TK
 497 %token   ASSERT_TK
 498
 499 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
 500 %token   CHAR_TK         INTEGRAL_TK
 501
 502 %token   FLOAT_TK        DOUBLE_TK          FP_TK
 503
 504 %token   ID_TK
 505
 506 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
 507
 508 %token   ASSIGN_ANY_TK   ASSIGN_TK
 509 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
 510
 511 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
 512 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
 513
 514 %type    <value>        modifiers MODIFIER_TK final synchronized
 515
 516 %type    <node>         super ID_TK identifier
 517 %type    <node>         name simple_name qualified_name
 518 %type    <node>         type_declaration compilation_unit
 519                         field_declaration method_declaration extends_interfaces
 520                         interfaces interface_type_list
 521                         import_declarations package_declaration
 522                         type_declarations interface_body
 523                         interface_member_declaration constant_declaration
 524                         interface_member_declarations interface_type
 525                         abstract_method_declaration
 526 %type    <node>         class_body_declaration class_member_declaration
 527                         static_initializer constructor_declaration block
 528 %type    <node>         class_body_declarations constructor_header
 529 %type    <node>         class_or_interface_type class_type class_type_list
 530                         constructor_declarator explicit_constructor_invocation
 531 %type    <node>         dim_expr dim_exprs this_or_super throws
 532
 533 %type    <node>         variable_declarator_id variable_declarator
 534                         variable_declarators variable_initializer
 535                         variable_initializers constructor_body
 536                         array_initializer
 537
 538 %type    <node>         class_body block_end constructor_block_end
 539 %type    <node>         statement statement_without_trailing_substatement
 540                         labeled_statement if_then_statement label_decl
 541                         if_then_else_statement while_statement for_statement
 542                         statement_nsi labeled_statement_nsi do_statement
 543                         if_then_else_statement_nsi while_statement_nsi
 544                         for_statement_nsi statement_expression_list for_init
 545                         for_update statement_expression expression_statement
 546                         primary_no_new_array expression primary
 547                         array_creation_expression array_type
 548                         class_instance_creation_expression field_access
 549                         method_invocation array_access something_dot_new
 550                         argument_list postfix_expression while_expression
 551                         post_increment_expression post_decrement_expression
 552                         unary_expression_not_plus_minus unary_expression
 553                         pre_increment_expression pre_decrement_expression
 554                         cast_expression
 555                         multiplicative_expression additive_expression
 556                         shift_expression relational_expression
 557                         equality_expression and_expression
 558                         exclusive_or_expression inclusive_or_expression
 559                         conditional_and_expression conditional_or_expression
 560                         conditional_expression assignment_expression
 561                         left_hand_side assignment for_header for_begin
 562                         constant_expression do_statement_begin empty_statement
 563                         switch_statement synchronized_statement throw_statement
 564                         try_statement assert_statement
 565                         switch_expression switch_block
 566                         catches catch_clause catch_clause_parameter finally
 567                         anonymous_class_creation trap_overflow_corner_case
 568 %type    <node>         return_statement break_statement continue_statement
 569
 570 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
 571 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
 572 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 573 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
 574 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
 575 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
 576 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
 577 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
 578 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
 579 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
 580 %type    <operator>     THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
 581 %type    <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
 582 %type    <operator>     NEW_TK ASSERT_TK
 583
 584 %type    <node>         method_body
 585
 586 %type    <node>         literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
 587                         STRING_LIT_TK NULL_TK VOID_TK
 588
 589 %type    <node>         IF_TK WHILE_TK FOR_TK
 590
 591 %type    <node>         formal_parameter_list formal_parameter
 592                         method_declarator method_header
 593
 594 %type    <node>         primitive_type reference_type type
 595                         BOOLEAN_TK INTEGRAL_TK FP_TK
 596
 597 /* Added or modified JDK 1.1 rule types  */
 598 %type    <node>         type_literals
 599
 600 %%
 601 /* 19.2 Production from 2.3: The Syntactic Grammar  */
 602 goal:  compilation_unit
 603                 {}
 604 ;
 605
 606 /* 19.3 Productions from 3: Lexical structure  */
 607 literal:
 608         INT_LIT_TK
 609 |       FP_LIT_TK
 610 |       BOOL_LIT_TK
 611 |       CHAR_LIT_TK
 612 |       STRING_LIT_TK
 613 |       NULL_TK
 614 ;
 615
 616 /* 19.4 Productions from 4: Types, Values and Variables  */
 617 type:
 618         primitive_type
 619 |       reference_type
 620 ;
 621
 622 primitive_type:
 623         INTEGRAL_TK
 624 |       FP_TK
 625 |       BOOLEAN_TK
 626 ;
 627
 628 reference_type:
 629         class_or_interface_type
 630 |       array_type
 631 ;
 632
 633 class_or_interface_type:
 634         name
 635 ;
 636
 637 class_type:
 638         class_or_interface_type /* Default rule */
 639 ;
 640
 641 interface_type:
 642          class_or_interface_type
 643 ;
 644
 645 array_type:
 646         primitive_type dims
 647                 {
 648                   int osb = pop_current_osb (ctxp);
 649                   tree t = build_java_array_type (($1), -1);
 650                   while (--osb)
 651                     t = build_unresolved_array_type (t);
 652                   $$ = t;
 653                 }
 654 |       name dims
 655                 {
 656                   int osb = pop_current_osb (ctxp);
 657                   tree t = $1;
 658                   while (osb--)
 659                     t = build_unresolved_array_type (t);
 660                   $$ = t;
 661                 }
 662 ;
 663
 664 /* 19.5 Productions from 6: Names  */
 665 name:
 666         simple_name             /* Default rule */
 667 |       qualified_name          /* Default rule */
 668 ;
 669
 670 simple_name:
 671         identifier              /* Default rule */
 672 ;
 673
 674 qualified_name:
 675         name DOT_TK identifier
 676                 { $$ = make_qualified_name ($1, $3, $2.location); }
 677 ;
 678
 679 identifier:
 680         ID_TK
 681 ;
 682
 683 /* 19.6: Production from 7: Packages  */
 684 compilation_unit:
 685                 {$$ = NULL;}
 686 |       package_declaration
 687 |       import_declarations
 688 |       type_declarations
 689 |       package_declaration import_declarations
 690 |       package_declaration type_declarations
 691 |       import_declarations type_declarations
 692 |       package_declaration import_declarations type_declarations
 693 ;
 694
 695 import_declarations:
 696         import_declaration
 697                 {
 698                   $$ = NULL;
 699                 }
 700 |       import_declarations import_declaration
 701                 {
 702                   $$ = NULL;
 703                 }
 704 ;
 705
 706 type_declarations:
 707         type_declaration
 708 |       type_declarations type_declaration
 709 ;
 710
 711 package_declaration:
 712         PACKAGE_TK name SC_TK
 713                 {
 714                   ctxp->package = EXPR_WFL_NODE ($2);
 715                   register_package (ctxp->package);
 716                 }
 717 |       PACKAGE_TK error
 718                 {yyerror ("Missing name"); RECOVER;}
 719 |       PACKAGE_TK name error
 720                 {yyerror ("';' expected"); RECOVER;}
 721 ;
 722
 723 import_declaration:
 724         single_type_import_declaration
 725 |       type_import_on_demand_declaration
 726 ;
 727
 728 single_type_import_declaration:
 729         IMPORT_TK name SC_TK
 730                 {
 731                   tree name = EXPR_WFL_NODE ($2), last_name;
 732                   int   i = IDENTIFIER_LENGTH (name)-1;
 733                   const char *last = &IDENTIFIER_POINTER (name)[i];
 734                   while (last != IDENTIFIER_POINTER (name))
 735                     {
 736                       if (last [0] == '.')
 737                         break;
 738                       last--;
 739                     }
 740                   last_name = get_identifier (++last);
 741                   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
 742                     {
 743                       tree err = find_name_in_single_imports (last_name);
 744                       if (err && err != name)
 745                         parse_error_context
 746                           ($2, "Ambiguous class: `%s' and `%s'",
 747                            IDENTIFIER_POINTER (name),
 748                            IDENTIFIER_POINTER (err));
 749                       else
 750                         REGISTER_IMPORT ($2, last_name);
 751                     }
 752                   else
 753                     REGISTER_IMPORT ($2, last_name);
 754                 }
 755 |       IMPORT_TK error
 756                 {yyerror ("Missing name"); RECOVER;}
 757 |       IMPORT_TK name error
 758                 {yyerror ("';' expected"); RECOVER;}
 759 ;
 760
 761 type_import_on_demand_declaration:
 762         IMPORT_TK name DOT_TK MULT_TK SC_TK
 763                 {
 764                   tree name = EXPR_WFL_NODE ($2);
 765                   tree it;
 766                   /* Search for duplicates. */
 767                   for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
 768                     if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
 769                       break;
 770                   /* Don't import the same thing more than once, just ignore
 771                      duplicates (7.5.2) */
 772                   if (! it)
 773                     {
 774                       read_import_dir ($2);
 775                       ctxp->import_demand_list =
 776                         chainon (ctxp->import_demand_list,
 777                                  build_tree_list ($2, NULL_TREE));
 778                     }
 779                 }
 780 |       IMPORT_TK name DOT_TK error
 781                 {yyerror ("'*' expected"); RECOVER;}
 782 |       IMPORT_TK name DOT_TK MULT_TK error
 783                 {yyerror ("';' expected"); RECOVER;}
 784 ;
 785
 786 type_declaration:
 787         class_declaration
 788                 { end_class_declaration (0); }
 789 |       interface_declaration
 790                 { end_class_declaration (0); }
 791 |       empty_statement
 792 |       error
 793                 {
 794                   YYERROR_NOW;
 795                   yyerror ("Class or interface declaration expected");
 796                 }
 797 ;
 798
 799 /* 19.7 Shortened from the original:
 800    modifiers: modifier | modifiers modifier
 801    modifier: any of public...  */
 802 modifiers:
 803         MODIFIER_TK
 804                 {
 805                   $$ = (1 << $1);
 806                 }
 807 |       modifiers MODIFIER_TK
 808                 {
 809                   int acc = (1 << $2);
 810                   if ($$ & acc)
 811                     parse_error_context
 812                       (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
 813                        java_accstring_lookup (acc));
 814                   else
 815                     {
 816                       $$ |= acc;
 817                     }
 818                 }
 819 ;
 820
 821 /* 19.8.1 Production from $8.1: Class Declaration */
 822 class_declaration:
 823         modifiers CLASS_TK identifier super interfaces
 824                 { create_class ($1, $3, $4, $5); }
 825         class_body
 826                 {;}
 827 |       CLASS_TK identifier super interfaces
 828                 { create_class (0, $2, $3, $4); }
 829         class_body
 830                 {;}
 831 |       modifiers CLASS_TK error
 832                 { yyerror ("Missing class name"); RECOVER; }
 833 |       CLASS_TK error
 834                 { yyerror ("Missing class name"); RECOVER; }
 835 |       CLASS_TK identifier error
 836                 {
 837                   if (!ctxp->class_err) yyerror ("'{' expected");
 838                   DRECOVER(class1);
 839                 }
 840 |       modifiers CLASS_TK identifier error
 841                 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
 842 ;
 843
 844 super:
 845                 { $$ = NULL; }
 846 |       EXTENDS_TK class_type
 847                 { $$ = $2; }
 848 |       EXTENDS_TK class_type error
 849                 {yyerror ("'{' expected"); ctxp->class_err=1;}
 850 |       EXTENDS_TK error
 851                 {yyerror ("Missing super class name"); ctxp->class_err=1;}
 852 ;
 853
 854 interfaces:
 855                 { $$ = NULL_TREE; }
 856 |       IMPLEMENTS_TK interface_type_list
 857                 { $$ = $2; }
 858 |       IMPLEMENTS_TK error
 859                 {
 860                   ctxp->class_err=1;
 861                   yyerror ("Missing interface name");
 862                 }
 863 ;
 864
 865 interface_type_list:
 866         interface_type
 867                 {
 868                   ctxp->interface_number = 1;
 869                   $$ = build_tree_list ($1, NULL_TREE);
 870                 }
 871 |       interface_type_list C_TK interface_type
 872                 {
 873                   ctxp->interface_number++;
 874                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
 875                 }
 876 |       interface_type_list C_TK error
 877                 {yyerror ("Missing interface name"); RECOVER;}
 878 ;
 879
 880 class_body:
 881         OCB_TK CCB_TK
 882                 {
 883                   /* Store the location of the `}' when doing xrefs */
 884                   if (flag_emit_xref)
 885                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 886                       EXPR_WFL_ADD_COL ($2.location, 1);
 887                   $$ = GET_CPC ();
 888                 }
 889 |       OCB_TK class_body_declarations CCB_TK
 890                 {
 891                   /* Store the location of the `}' when doing xrefs */
 892                   if (flag_emit_xref)
 893                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 894                       EXPR_WFL_ADD_COL ($3.location, 1);
 895                   $$ = GET_CPC ();
 896                 }
 897 ;
 898
 899 class_body_declarations:
 900         class_body_declaration
 901 |       class_body_declarations class_body_declaration
 902 ;
 903
 904 class_body_declaration:
 905         class_member_declaration
 906 |       static_initializer
 907 |       constructor_declaration
 908 |       block                   /* Added, JDK1.1, instance initializer */
 909                 {
 910                   if ($1 != empty_stmt_node)
 911                     {
 912                       TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
 913                       SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
 914                     }
 915                 }
 916 ;
 917
 918 class_member_declaration:
 919         field_declaration
 920 |       method_declaration
 921 |       class_declaration       /* Added, JDK1.1 inner classes */
 922                 { end_class_declaration (1); }
 923 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
 924                 { end_class_declaration (1); }
 925 |       empty_statement
 926 ;
 927
 928 /* 19.8.2 Productions from 8.3: Field Declarations  */
 929 field_declaration:
 930         type variable_declarators SC_TK
 931                 { register_fields (0, $1, $2); }
 932 |       modifiers type variable_declarators SC_TK
 933                 {
 934                   check_modifiers
 935                     ("Illegal modifier `%s' for field declaration",
 936                      $1, FIELD_MODIFIERS);
 937                   check_modifiers_consistency ($1);
 938                   register_fields ($1, $2, $3);
 939                 }
 940 ;
 941
 942 variable_declarators:
 943         /* Should we use build_decl_list () instead ? FIXME */
 944         variable_declarator     /* Default rule */
 945 |       variable_declarators C_TK variable_declarator
 946                 { $$ = chainon ($1, $3); }
 947 |       variable_declarators C_TK error
 948                 {yyerror ("Missing term"); RECOVER;}
 949 ;
 950
 951 variable_declarator:
 952         variable_declarator_id
 953                 { $$ = build_tree_list ($1, NULL_TREE); }
 954 |       variable_declarator_id ASSIGN_TK variable_initializer
 955                 {
 956                   if (java_error_count)
 957                     $3 = NULL_TREE;
 958                   $$ = build_tree_list
 959                     ($1, build_assignment ($2.token, $2.location, $1, $3));
 960                 }
 961 |       variable_declarator_id ASSIGN_TK error
 962                 {
 963                   yyerror ("Missing variable initializer");
 964                   $$ = build_tree_list ($1, NULL_TREE);
 965                   RECOVER;
 966                 }
 967 |       variable_declarator_id ASSIGN_TK variable_initializer error
 968                 {
 969                   yyerror ("';' expected");
 970                   $$ = build_tree_list ($1, NULL_TREE);
 971                   RECOVER;
 972                 }
 973 ;
 974
 975 variable_declarator_id:
 976         identifier
 977 |       variable_declarator_id OSB_TK CSB_TK
 978                 { $$ = build_unresolved_array_type ($1); }
 979 |       identifier error
 980                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
 981 |       variable_declarator_id OSB_TK error
 982                 {
 983                   yyerror ("']' expected");
 984                   DRECOVER(vdi);
 985                 }
 986 |       variable_declarator_id CSB_TK error
 987                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
 988 ;
 989
 990 variable_initializer:
 991         expression
 992 |       array_initializer
 993 ;
 994
 995 /* 19.8.3 Productions from 8.4: Method Declarations  */
 996 method_declaration:
 997         method_header
 998                 {
 999                   current_function_decl = $1;
1000                   if (current_function_decl
1001                       && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1002                     source_start_java_method (current_function_decl);
1003                   else
1004                     current_function_decl = NULL_TREE;
1005                 }
1006         method_body
1007                 { finish_method_declaration ($3); }
1008 |       method_header error
1009                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1010 ;
1011
1012 method_header:
1013         type method_declarator throws
1014                 { $$ = method_header (0, $1, $2, $3); }
1015 |       VOID_TK method_declarator throws
1016                 { $$ = method_header (0, void_type_node, $2, $3); }
1017 |       modifiers type method_declarator throws
1018                 { $$ = method_header ($1, $2, $3, $4); }
1019 |       modifiers VOID_TK method_declarator throws
1020                 { $$ = method_header ($1, void_type_node, $3, $4); }
1021 |       type error
1022                 {
1023                   yyerror ("Invalid method declaration, method name required");
1024                   RECOVER;
1025                 }
1026 |       modifiers type error
1027                 {
1028                   yyerror ("Identifier expected");
1029                   RECOVER;
1030                 }
1031 |       VOID_TK error
1032                 {
1033                   yyerror ("Identifier expected");
1034                   RECOVER;
1035                 }
1036 |       modifiers VOID_TK error
1037                 {
1038                   yyerror ("Identifier expected");
1039                   RECOVER;
1040                 }
1041 |       modifiers error
1042                 {
1043                   yyerror ("Invalid method declaration, return type required");
1044                   RECOVER;
1045                 }
1046 ;
1047
1048 method_declarator:
1049         identifier OP_TK CP_TK
1050                 {
1051                   ctxp->formal_parameter_number = 0;
1052                   $$ = method_declarator ($1, NULL_TREE);
1053                 }
1054 |       identifier OP_TK formal_parameter_list CP_TK
1055                 { $$ = method_declarator ($1, $3); }
1056 |       method_declarator OSB_TK CSB_TK
1057                 {
1058                   EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1059                   TREE_PURPOSE ($1) =
1060                     build_unresolved_array_type (TREE_PURPOSE ($1));
1061                   parse_warning_context
1062                     (wfl_operator,
1063                      "Discouraged form of returned type specification");
1064                 }
1065 |       identifier OP_TK error
1066                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1067 |       method_declarator OSB_TK error
1068                 {yyerror ("']' expected"); RECOVER;}
1069 ;
1070
1071 formal_parameter_list:
1072         formal_parameter
1073                 {
1074                   ctxp->formal_parameter_number = 1;
1075                 }
1076 |       formal_parameter_list C_TK formal_parameter
1077                 {
1078                   ctxp->formal_parameter_number += 1;
1079                   $$ = chainon ($1, $3);
1080                 }
1081 |       formal_parameter_list C_TK error
1082                 { yyerror ("Missing formal parameter term"); RECOVER; }
1083 ;
1084
1085 formal_parameter:
1086         type variable_declarator_id
1087                 {
1088                   $$ = build_tree_list ($2, $1);
1089                 }
1090 |       final type variable_declarator_id /* Added, JDK1.1 final parms */
1091                 {
1092                   $$ = build_tree_list ($3, $2);
1093                   ARG_FINAL_P ($$) = 1;
1094                 }
1095 |       type error
1096                 {
1097                   yyerror ("Missing identifier"); RECOVER;
1098                   $$ = NULL_TREE;
1099                 }
1100 |       final type error
1101                 {
1102                   yyerror ("Missing identifier"); RECOVER;
1103                   $$ = NULL_TREE;
1104                 }
1105 ;
1106
1107 final:
1108         modifiers
1109                 {
1110                   check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1111                                    $1, ACC_FINAL);
1112                   if ($1 != ACC_FINAL)
1113                     MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1114                 }
1115 ;
1116
1117 throws:
1118                 { $$ = NULL_TREE; }
1119 |       THROWS_TK class_type_list
1120                 { $$ = $2; }
1121 |       THROWS_TK error
1122                 {yyerror ("Missing class type term"); RECOVER;}
1123 ;
1124
1125 class_type_list:
1126         class_type
1127                 { $$ = build_tree_list ($1, $1); }
1128 |       class_type_list C_TK class_type
1129                 { $$ = tree_cons ($3, $3, $1); }
1130 |       class_type_list C_TK error
1131                 {yyerror ("Missing class type term"); RECOVER;}
1132 ;
1133
1134 method_body:
1135         block
1136 |       SC_TK { $$ = NULL_TREE; }
1137 ;
1138
1139 /* 19.8.4 Productions from 8.5: Static Initializers  */
1140 static_initializer:
1141         static block
1142                 {
1143                   TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1144                   SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1145                   current_static_block = NULL_TREE;
1146                 }
1147 ;
1148
1149 static:                         /* Test lval.sub_token here */
1150         modifiers
1151                 {
1152                   check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1153                   /* Can't have a static initializer in an innerclass */
1154                   if ($1 | ACC_STATIC &&
1155                       GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1156                     parse_error_context
1157                       (MODIFIER_WFL (STATIC_TK),
1158                        "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1159                        IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1160                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1161                 }
1162 ;
1163
1164 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1165 constructor_declaration:
1166         constructor_header
1167                 {
1168                   current_function_decl = $1;
1169                   source_start_java_method (current_function_decl);
1170                 }
1171         constructor_body
1172                 { finish_method_declaration ($3); }
1173 ;
1174
1175 constructor_header:
1176         constructor_declarator throws
1177                 { $$ = method_header (0, NULL_TREE, $1, $2); }
1178 |       modifiers constructor_declarator throws
1179                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1180 ;
1181
1182 constructor_declarator:
1183         simple_name OP_TK CP_TK
1184                 {
1185                   ctxp->formal_parameter_number = 0;
1186                   $$ = method_declarator ($1, NULL_TREE);
1187                 }
1188 |       simple_name OP_TK formal_parameter_list CP_TK
1189                 { $$ = method_declarator ($1, $3); }
1190 ;
1191
1192 constructor_body:
1193         /* Unlike regular method, we always need a complete (empty)
1194            body so we can safely perform all the required code
1195            addition (super invocation and field initialization) */
1196         block_begin constructor_block_end
1197                 {
1198                   BLOCK_EXPR_BODY ($2) = empty_stmt_node;
1199                   $$ = $2;
1200                 }
1201 |       block_begin explicit_constructor_invocation constructor_block_end
1202                 { $$ = $3; }
1203 |       block_begin block_statements constructor_block_end
1204                 { $$ = $3; }
1205 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1206                 { $$ = $4; }
1207 ;
1208
1209 constructor_block_end:
1210         block_end
1211 ;
1212
1213 /* Error recovery for that rule moved down expression_statement: rule.  */
1214 explicit_constructor_invocation:
1215         this_or_super OP_TK CP_TK SC_TK
1216                 {
1217                   $$ = build_method_invocation ($1, NULL_TREE);
1218                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1219                   $$ = java_method_add_stmt (current_function_decl, $$);
1220                 }
1221 |       this_or_super OP_TK argument_list CP_TK SC_TK
1222                 {
1223                   $$ = build_method_invocation ($1, $3);
1224                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1225                   $$ = java_method_add_stmt (current_function_decl, $$);
1226                 }
1227         /* Added, JDK1.1 inner classes. Modified because the rule
1228            'primary' couldn't work.  */
1229 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1230                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1231 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1232                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1233 ;
1234
1235 this_or_super:                  /* Added, simplifies error diagnostics */
1236         THIS_TK
1237                 {
1238                   tree wfl = build_wfl_node (this_identifier_node);
1239                   EXPR_WFL_LINECOL (wfl) = $1.location;
1240                   $$ = wfl;
1241                 }
1242 |       SUPER_TK
1243                 {
1244                   tree wfl = build_wfl_node (super_identifier_node);
1245                   EXPR_WFL_LINECOL (wfl) = $1.location;
1246                   $$ = wfl;
1247                 }
1248 ;
1249
1250 /* 19.9 Productions from 9: Interfaces  */
1251 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1252 interface_declaration:
1253         INTERFACE_TK identifier
1254                 { create_interface (0, $2, NULL_TREE); }
1255         interface_body
1256                 { ; }
1257 |       modifiers INTERFACE_TK identifier
1258                 { create_interface ($1, $3, NULL_TREE); }
1259         interface_body
1260                 { ; }
1261 |       INTERFACE_TK identifier extends_interfaces
1262                 { create_interface (0, $2, $3); }
1263         interface_body
1264                 { ; }
1265 |       modifiers INTERFACE_TK identifier extends_interfaces
1266                 { create_interface ($1, $3, $4); }
1267         interface_body
1268                 { ; }
1269 |       INTERFACE_TK identifier error
1270                 { yyerror ("'{' expected"); RECOVER; }
1271 |       modifiers INTERFACE_TK identifier error
1272                 { yyerror ("'{' expected"); RECOVER; }
1273 ;
1274
1275 extends_interfaces:
1276         EXTENDS_TK interface_type
1277                 {
1278                   ctxp->interface_number = 1;
1279                   $$ = build_tree_list ($2, NULL_TREE);
1280                 }
1281 |       extends_interfaces C_TK interface_type
1282                 {
1283                   ctxp->interface_number++;
1284                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1285                 }
1286 |       EXTENDS_TK error
1287                 {yyerror ("Invalid interface type"); RECOVER;}
1288 |       extends_interfaces C_TK error
1289                 {yyerror ("Missing term"); RECOVER;}
1290 ;
1291
1292 interface_body:
1293         OCB_TK CCB_TK
1294                 { $$ = NULL_TREE; }
1295 |       OCB_TK interface_member_declarations CCB_TK
1296                 { $$ = NULL_TREE; }
1297 ;
1298
1299 interface_member_declarations:
1300         interface_member_declaration
1301 |       interface_member_declarations interface_member_declaration
1302 ;
1303
1304 interface_member_declaration:
1305         constant_declaration
1306 |       abstract_method_declaration
1307 |       class_declaration       /* Added, JDK1.1 inner classes */
1308                 { end_class_declaration (1); }
1309 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
1310                 { end_class_declaration (1); }
1311 ;
1312
1313 constant_declaration:
1314         field_declaration
1315 ;
1316
1317 abstract_method_declaration:
1318         method_header SC_TK
1319                 {
1320                   check_abstract_method_header ($1);
1321                   current_function_decl = NULL_TREE; /* FIXME ? */
1322                 }
1323 |       method_header error
1324                 {yyerror ("';' expected"); RECOVER;}
1325 ;
1326
1327 /* 19.10 Productions from 10: Arrays  */
1328 array_initializer:
1329         OCB_TK CCB_TK
1330                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1331 |       OCB_TK C_TK CCB_TK
1332                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1333 |       OCB_TK variable_initializers CCB_TK
1334                 { $$ = build_new_array_init ($1.location, $2); }
1335 |       OCB_TK variable_initializers C_TK CCB_TK
1336                 { $$ = build_new_array_init ($1.location, $2); }
1337 ;
1338
1339 variable_initializers:
1340         variable_initializer
1341                 {
1342                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1343                                   $1, NULL_TREE);
1344                 }
1345 |       variable_initializers C_TK variable_initializer
1346                 {
1347                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1348                 }
1349 |       variable_initializers C_TK error
1350                 {yyerror ("Missing term"); RECOVER;}
1351 ;
1352
1353 /* 19.11 Production from 14: Blocks and Statements  */
1354 block:
1355         block_begin block_end
1356                 { $$ = $2; }
1357 |       block_begin block_statements block_end
1358                 { $$ = $3; }
1359 ;
1360
1361 block_begin:
1362         OCB_TK
1363                 { enter_block (); }
1364 ;
1365
1366 block_end:
1367         CCB_TK
1368                 {
1369                   maybe_absorb_scoping_blocks ();
1370                   /* Store the location of the `}' when doing xrefs */
1371                   if (current_function_decl && flag_emit_xref)
1372                     DECL_END_SOURCE_LINE (current_function_decl) =
1373                       EXPR_WFL_ADD_COL ($1.location, 1);
1374                   $$ = exit_block ();
1375                   if (!BLOCK_SUBBLOCKS ($$))
1376                     BLOCK_SUBBLOCKS ($$) = empty_stmt_node;
1377                 }
1378 ;
1379
1380 block_statements:
1381         block_statement
1382 |       block_statements block_statement
1383 ;
1384
1385 block_statement:
1386         local_variable_declaration_statement
1387 |       statement
1388                 { java_method_add_stmt (current_function_decl, $1); }
1389 |       class_declaration       /* Added, JDK1.1 local classes */
1390                 {
1391                   LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1392                   end_class_declaration (1);
1393                 }
1394 ;
1395
1396 local_variable_declaration_statement:
1397         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1398 ;
1399
1400 local_variable_declaration:
1401         type variable_declarators
1402                 { declare_local_variables (0, $1, $2); }
1403 |       final type variable_declarators /* Added, JDK1.1 final locals */
1404                 { declare_local_variables ($1, $2, $3); }
1405 ;
1406
1407 statement:
1408         statement_without_trailing_substatement
1409 |       labeled_statement
1410 |       if_then_statement
1411 |       if_then_else_statement
1412 |       while_statement
1413 |       for_statement
1414                 { $$ = exit_block (); }
1415 ;
1416
1417 statement_nsi:
1418         statement_without_trailing_substatement
1419 |       labeled_statement_nsi
1420 |       if_then_else_statement_nsi
1421 |       while_statement_nsi
1422 |       for_statement_nsi
1423                 { $$ = exit_block (); }
1424 ;
1425
1426 statement_without_trailing_substatement:
1427         block
1428 |       empty_statement
1429 |       expression_statement
1430 |       switch_statement
1431 |       do_statement
1432 |       break_statement
1433 |       continue_statement
1434 |       return_statement
1435 |       synchronized_statement
1436 |       throw_statement
1437 |       try_statement
1438 |       assert_statement
1439 ;
1440
1441 empty_statement:
1442         SC_TK
1443                 {
1444                   if (flag_extraneous_semicolon
1445                       && ! current_static_block
1446                       && (! current_function_decl ||
1447                           /* Verify we're not in a inner class declaration */
1448                           (GET_CPC () != TYPE_NAME
1449                            (DECL_CONTEXT (current_function_decl)))))
1450
1451                     {
1452                       EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1453                       parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1454                     }
1455                   $$ = empty_stmt_node;
1456                 }
1457 ;
1458
1459 label_decl:
1460         identifier REL_CL_TK
1461                 {
1462                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1463                                             EXPR_WFL_NODE ($1));
1464                   pushlevel (2);
1465                   push_labeled_block ($$);
1466                   PUSH_LABELED_BLOCK ($$);
1467                 }
1468 ;
1469
1470 labeled_statement:
1471         label_decl statement
1472                 { $$ = finish_labeled_statement ($1, $2); }
1473 |       identifier error
1474                 {yyerror ("':' expected"); RECOVER;}
1475 ;
1476
1477 labeled_statement_nsi:
1478         label_decl statement_nsi
1479                 { $$ = finish_labeled_statement ($1, $2); }
1480 ;
1481
1482 /* We concentrate here a bunch of error handling rules that we couldn't write
1483    earlier, because expression_statement catches a missing ';'.  */
1484 expression_statement:
1485         statement_expression SC_TK
1486                 {
1487                   /* We have a statement. Generate a WFL around it so
1488                      we can debug it */
1489                   $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1490                   /* We know we have a statement, so set the debug
1491                      info to be eventually generate here. */
1492                   $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1493                 }
1494 |       error SC_TK
1495                 {
1496                   YYNOT_TWICE yyerror ("Invalid expression statement");
1497                   DRECOVER (expr_stmt);
1498                 }
1499 |       error OCB_TK
1500                 {
1501                   YYNOT_TWICE yyerror ("Invalid expression statement");
1502                   DRECOVER (expr_stmt);
1503                 }
1504 |       error CCB_TK
1505                 {
1506                   YYNOT_TWICE yyerror ("Invalid expression statement");
1507                   DRECOVER (expr_stmt);
1508                 }
1509 |       this_or_super OP_TK error
1510                 {yyerror ("')' expected"); RECOVER;}
1511 |       this_or_super OP_TK CP_TK error
1512                 {
1513                   parse_ctor_invocation_error ();
1514                   RECOVER;
1515                 }
1516 |       this_or_super OP_TK argument_list error
1517                 {yyerror ("')' expected"); RECOVER;}
1518 |       this_or_super OP_TK argument_list CP_TK error
1519                 {
1520                   parse_ctor_invocation_error ();
1521                   RECOVER;
1522                 }
1523 |       name DOT_TK SUPER_TK error
1524                 {yyerror ("'(' expected"); RECOVER;}
1525 |       name DOT_TK SUPER_TK OP_TK error
1526                 {yyerror ("')' expected"); RECOVER;}
1527 |       name DOT_TK SUPER_TK OP_TK argument_list error
1528                 {yyerror ("')' expected"); RECOVER;}
1529 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1530                 {yyerror ("';' expected"); RECOVER;}
1531 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1532                 {yyerror ("';' expected"); RECOVER;}
1533 ;
1534
1535 statement_expression:
1536         assignment
1537 |       pre_increment_expression
1538 |       pre_decrement_expression
1539 |       post_increment_expression
1540 |       post_decrement_expression
1541 |       method_invocation
1542 |       class_instance_creation_expression
1543 ;
1544
1545 if_then_statement:
1546         IF_TK OP_TK expression CP_TK statement
1547                 {
1548                   $$ = build_if_else_statement ($2.location, $3,
1549                                                 $5, NULL_TREE);
1550                 }
1551 |       IF_TK error
1552                 {yyerror ("'(' expected"); RECOVER;}
1553 |       IF_TK OP_TK error
1554                 {yyerror ("Missing term"); RECOVER;}
1555 |       IF_TK OP_TK expression error
1556                 {yyerror ("')' expected"); RECOVER;}
1557 ;
1558
1559 if_then_else_statement:
1560         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1561                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1562 ;
1563
1564 if_then_else_statement_nsi:
1565         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1566                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1567 ;
1568
1569 switch_statement:
1570         switch_expression
1571                 {
1572                   enter_block ();
1573                 }
1574         switch_block
1575                 {
1576                   /* Make into "proper list" of COMPOUND_EXPRs.
1577                      I.e. make the last statement also have its own
1578                      COMPOUND_EXPR. */
1579                   maybe_absorb_scoping_blocks ();
1580                   TREE_OPERAND ($1, 1) = exit_block ();
1581                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1582                 }
1583 ;
1584
1585 switch_expression:
1586         SWITCH_TK OP_TK expression CP_TK
1587                 {
1588                   $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1589                   EXPR_WFL_LINECOL ($$) = $2.location;
1590                 }
1591 |       SWITCH_TK error
1592                 {yyerror ("'(' expected"); RECOVER;}
1593 |       SWITCH_TK OP_TK error
1594                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1595 |       SWITCH_TK OP_TK expression CP_TK error
1596                 {yyerror ("'{' expected"); RECOVER;}
1597 ;
1598
1599 /* Default assignment is there to avoid type node on switch_block
1600    node. */
1601
1602 switch_block:
1603         OCB_TK CCB_TK
1604                 { $$ = NULL_TREE; }
1605 |       OCB_TK switch_labels CCB_TK
1606                 { $$ = NULL_TREE; }
1607 |       OCB_TK switch_block_statement_groups CCB_TK
1608                 { $$ = NULL_TREE; }
1609 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1610                 { $$ = NULL_TREE; }
1611 ;
1612
1613 switch_block_statement_groups:
1614         switch_block_statement_group
1615 |       switch_block_statement_groups switch_block_statement_group
1616 ;
1617
1618 switch_block_statement_group:
1619         switch_labels block_statements
1620 ;
1621
1622 switch_labels:
1623         switch_label
1624 |       switch_labels switch_label
1625 ;
1626
1627 switch_label:
1628         CASE_TK constant_expression REL_CL_TK
1629                 {
1630                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1631                   EXPR_WFL_LINECOL (lab) = $1.location;
1632                   java_method_add_stmt (current_function_decl, lab);
1633                 }
1634 |       DEFAULT_TK REL_CL_TK
1635                 {
1636                   tree lab = build (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
1637                   EXPR_WFL_LINECOL (lab) = $1.location;
1638                   java_method_add_stmt (current_function_decl, lab);
1639                 }
1640 |       CASE_TK error
1641                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1642 |       CASE_TK constant_expression error
1643                 {yyerror ("':' expected"); RECOVER;}
1644 |       DEFAULT_TK error
1645                 {yyerror ("':' expected"); RECOVER;}
1646 ;
1647
1648 while_expression:
1649         WHILE_TK OP_TK expression CP_TK
1650                 {
1651                   tree body = build_loop_body ($2.location, $3, 0);
1652                   $$ = build_new_loop (body);
1653                 }
1654 ;
1655
1656 while_statement:
1657         while_expression statement
1658                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1659 |       WHILE_TK error
1660                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1661 |       WHILE_TK OP_TK error
1662                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1663 |       WHILE_TK OP_TK expression error
1664                 {yyerror ("')' expected"); RECOVER;}
1665 ;
1666
1667 while_statement_nsi:
1668         while_expression statement_nsi
1669                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1670 ;
1671
1672 do_statement_begin:
1673         DO_TK
1674                 {
1675                   tree body = build_loop_body (0, NULL_TREE, 1);
1676                   $$ = build_new_loop (body);
1677                 }
1678         /* Need error handing here. FIXME */
1679 ;
1680
1681 do_statement:
1682         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1683                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1684 ;
1685
1686 for_statement:
1687         for_begin SC_TK expression SC_TK for_update CP_TK statement
1688                 {
1689                   if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1690                     $3 = build_wfl_node ($3);
1691                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1692                 }
1693 |       for_begin SC_TK SC_TK for_update CP_TK statement
1694                 {
1695                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1696                   /* We have not condition, so we get rid of the EXIT_EXPR */
1697                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1698                     empty_stmt_node;
1699                 }
1700 |       for_begin SC_TK error
1701                 {yyerror ("Invalid control expression"); RECOVER;}
1702 |       for_begin SC_TK expression SC_TK error
1703                 {yyerror ("Invalid update expression"); RECOVER;}
1704 |       for_begin SC_TK SC_TK error
1705                 {yyerror ("Invalid update expression"); RECOVER;}
1706 ;
1707
1708 for_statement_nsi:
1709         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1710                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1711 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1712                 {
1713                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1714                   /* We have not condition, so we get rid of the EXIT_EXPR */
1715                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1716                     empty_stmt_node;
1717                 }
1718 ;
1719
1720 for_header:
1721         FOR_TK OP_TK
1722                 {
1723                   /* This scope defined for local variable that may be
1724                      defined within the scope of the for loop */
1725                   enter_block ();
1726                 }
1727 |       FOR_TK error
1728                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1729 |       FOR_TK OP_TK error
1730                 {yyerror ("Invalid init statement"); RECOVER;}
1731 ;
1732
1733 for_begin:
1734         for_header for_init
1735                 {
1736                   /* We now declare the loop body. The loop is
1737                      declared as a for loop. */
1738                   tree body = build_loop_body (0, NULL_TREE, 0);
1739                   $$ =  build_new_loop (body);
1740                   FOR_LOOP_P ($$) = 1;
1741                   /* The loop is added to the current block the for
1742                      statement is defined within */
1743                   java_method_add_stmt (current_function_decl, $$);
1744                 }
1745 ;
1746 for_init:                       /* Can be empty */
1747                 { $$ = empty_stmt_node; }
1748 |       statement_expression_list
1749                 {
1750                   /* Init statement recorded within the previously
1751                      defined block scope */
1752                   $$ = java_method_add_stmt (current_function_decl, $1);
1753                 }
1754 |       local_variable_declaration
1755                 {
1756                   /* Local variable are recorded within the previously
1757                      defined block scope */
1758                   $$ = NULL_TREE;
1759                 }
1760 |       statement_expression_list error
1761                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1762 ;
1763
1764 for_update:                     /* Can be empty */
1765                 {$$ = empty_stmt_node;}
1766 |       statement_expression_list
1767                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1768 ;
1769
1770 statement_expression_list:
1771         statement_expression
1772                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1773 |       statement_expression_list C_TK statement_expression
1774                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1775 |       statement_expression_list C_TK error
1776                 {yyerror ("Missing term"); RECOVER;}
1777 ;
1778
1779 break_statement:
1780         BREAK_TK SC_TK
1781                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1782 |       BREAK_TK identifier SC_TK
1783                 { $$ = build_bc_statement ($1.location, 1, $2); }
1784 |       BREAK_TK error
1785                 {yyerror ("Missing term"); RECOVER;}
1786 |       BREAK_TK identifier error
1787                 {yyerror ("';' expected"); RECOVER;}
1788 ;
1789
1790 continue_statement:
1791         CONTINUE_TK SC_TK
1792                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1793 |       CONTINUE_TK identifier SC_TK
1794                 { $$ = build_bc_statement ($1.location, 0, $2); }
1795 |       CONTINUE_TK error
1796                 {yyerror ("Missing term"); RECOVER;}
1797 |       CONTINUE_TK identifier error
1798                 {yyerror ("';' expected"); RECOVER;}
1799 ;
1800
1801 return_statement:
1802         RETURN_TK SC_TK
1803                 { $$ = build_return ($1.location, NULL_TREE); }
1804 |       RETURN_TK expression SC_TK
1805                 { $$ = build_return ($1.location, $2); }
1806 |       RETURN_TK error
1807                 {yyerror ("Missing term"); RECOVER;}
1808 |       RETURN_TK expression error
1809                 {yyerror ("';' expected"); RECOVER;}
1810 ;
1811
1812 throw_statement:
1813         THROW_TK expression SC_TK
1814                 {
1815                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1816                   EXPR_WFL_LINECOL ($$) = $1.location;
1817                 }
1818 |       THROW_TK error
1819                 {yyerror ("Missing term"); RECOVER;}
1820 |       THROW_TK expression error
1821                 {yyerror ("';' expected"); RECOVER;}
1822 ;
1823
1824 assert_statement:
1825         ASSERT_TK expression REL_CL_TK expression SC_TK
1826                 {
1827                   $$ = build_assertion ($1.location, $2, $4);
1828                 }
1829 |       ASSERT_TK expression SC_TK
1830                 {
1831                   $$ = build_assertion ($1.location, $2, NULL_TREE);
1832                 }
1833 |       ASSERT_TK error
1834                 {yyerror ("Missing term"); RECOVER;}
1835 |       ASSERT_TK expression error
1836                 {yyerror ("';' expected"); RECOVER;}
1837 ;
1838
1839 synchronized_statement:
1840         synchronized OP_TK expression CP_TK block
1841                 {
1842                   $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1843                   EXPR_WFL_LINECOL ($$) =
1844                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1845                 }
1846 |       synchronized OP_TK expression CP_TK error
1847                 {yyerror ("'{' expected"); RECOVER;}
1848 |       synchronized error
1849                 {yyerror ("'(' expected"); RECOVER;}
1850 |       synchronized OP_TK error CP_TK
1851                 {yyerror ("Missing term"); RECOVER;}
1852 |       synchronized OP_TK error
1853                 {yyerror ("Missing term"); RECOVER;}
1854 ;
1855
1856 synchronized:
1857         modifiers
1858                 {
1859                   check_modifiers (
1860              "Illegal modifier `%s'. Only `synchronized' was expected here",
1861                                    $1, ACC_SYNCHRONIZED);
1862                   if ($1 != ACC_SYNCHRONIZED)
1863                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1864                       build_wfl_node (NULL_TREE);
1865                 }
1866 ;
1867
1868 try_statement:
1869         TRY_TK block catches
1870                 { $$ = build_try_statement ($1.location, $2, $3); }
1871 |       TRY_TK block finally
1872                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1873 |       TRY_TK block catches finally
1874                 { $$ = build_try_finally_statement
1875                     ($1.location, build_try_statement ($1.location,
1876                                                        $2, $3), $4);
1877                 }
1878 |       TRY_TK error
1879                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1880 ;
1881
1882 catches:
1883         catch_clause
1884 |       catches catch_clause
1885                 {
1886                   TREE_CHAIN ($2) = $1;
1887                   $$ = $2;
1888                 }
1889 ;
1890
1891 catch_clause:
1892         catch_clause_parameter block
1893                 {
1894                   java_method_add_stmt (current_function_decl, $2);
1895                   exit_block ();
1896                   $$ = $1;
1897                 }
1898 ;
1899
1900 catch_clause_parameter:
1901         CATCH_TK OP_TK formal_parameter CP_TK
1902                 {
1903                   /* We add a block to define a scope for
1904                      formal_parameter (CCBP). The formal parameter is
1905                      declared initialized by the appropriate function
1906                      call */
1907                   tree ccpb = enter_block ();
1908                   tree init = build_assignment
1909                     (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1910                      build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1911                   declare_local_variables (0, TREE_VALUE ($3),
1912                                            build_tree_list (TREE_PURPOSE ($3),
1913                                                             init));
1914                   $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1915                   EXPR_WFL_LINECOL ($$) = $1.location;
1916                 }
1917 |       CATCH_TK error
1918                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1919 |       CATCH_TK OP_TK error
1920                 {
1921                   yyerror ("Missing term or ')' expected");
1922                   RECOVER; $$ = NULL_TREE;
1923                 }
1924 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1925                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1926 ;
1927
1928 finally:
1929         FINALLY_TK block
1930                 { $$ = $2; }
1931 |       FINALLY_TK error
1932                 {yyerror ("'{' expected"); RECOVER; }
1933 ;
1934
1935 /* 19.12 Production from 15: Expressions  */
1936 primary:
1937         primary_no_new_array
1938 |       array_creation_expression
1939 ;
1940
1941 primary_no_new_array:
1942         literal
1943 |       THIS_TK
1944                 { $$ = build_this ($1.location); }
1945 |       OP_TK expression CP_TK
1946                 {$$ = $2;}
1947 |       class_instance_creation_expression
1948 |       field_access
1949 |       method_invocation
1950 |       array_access
1951 |       type_literals
1952         /* Added, JDK1.1 inner classes. Documentation is wrong
1953            refering to a 'ClassName' (class_name) rule that doesn't
1954            exist. Used name: instead.  */
1955 |       name DOT_TK THIS_TK
1956                 {
1957                   tree wfl = build_wfl_node (this_identifier_node);
1958                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1959                 }
1960 |       OP_TK expression error
1961                 {yyerror ("')' expected"); RECOVER;}
1962 |       name DOT_TK error
1963                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1964 |       primitive_type DOT_TK error
1965                 {yyerror ("'class' expected" ); RECOVER;}
1966 |       VOID_TK DOT_TK error
1967                 {yyerror ("'class' expected" ); RECOVER;}
1968 ;
1969
1970 type_literals:
1971         name DOT_TK CLASS_TK
1972                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1973 |       array_type DOT_TK CLASS_TK
1974                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1975 |       primitive_type DOT_TK CLASS_TK
1976                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1977 |       VOID_TK DOT_TK CLASS_TK
1978                 {
1979                    $$ = build_incomplete_class_ref ($2.location,
1980                                                    void_type_node);
1981                 }
1982 ;
1983
1984 class_instance_creation_expression:
1985         NEW_TK class_type OP_TK argument_list CP_TK
1986                 { $$ = build_new_invocation ($2, $4); }
1987 |       NEW_TK class_type OP_TK CP_TK
1988                 { $$ = build_new_invocation ($2, NULL_TREE); }
1989 |       anonymous_class_creation
1990         /* Added, JDK1.1 inner classes, modified to use name or
1991            primary instead of primary solely which couldn't work in
1992            all situations.  */
1993 |       something_dot_new identifier OP_TK CP_TK
1994                 {
1995                   tree ctor = build_new_invocation ($2, NULL_TREE);
1996                   $$ = make_qualified_primary ($1, ctor,
1997                                                EXPR_WFL_LINECOL ($1));
1998                 }
1999 |       something_dot_new identifier OP_TK CP_TK class_body
2000 |       something_dot_new identifier OP_TK argument_list CP_TK
2001                 {
2002                   tree ctor = build_new_invocation ($2, $4);
2003                   $$ = make_qualified_primary ($1, ctor,
2004                                                EXPR_WFL_LINECOL ($1));
2005                 }
2006 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2007 |       NEW_TK error SC_TK
2008                 {yyerror ("'(' expected"); DRECOVER(new_1);}
2009 |       NEW_TK class_type error
2010                 {yyerror ("'(' expected"); RECOVER;}
2011 |       NEW_TK class_type OP_TK error
2012                 {yyerror ("')' or term expected"); RECOVER;}
2013 |       NEW_TK class_type OP_TK argument_list error
2014                 {yyerror ("')' expected"); RECOVER;}
2015 |       something_dot_new error
2016                 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2017 |       something_dot_new identifier error
2018                 {yyerror ("'(' expected"); RECOVER;}
2019 ;
2020
2021 /* Created after JDK1.1 rules originally added to
2022    class_instance_creation_expression, but modified to use
2023    'class_type' instead of 'TypeName' (type_name) which is mentionned
2024    in the documentation but doesn't exist. */
2025
2026 anonymous_class_creation:
2027         NEW_TK class_type OP_TK argument_list CP_TK
2028                 { create_anonymous_class ($1.location, $2); }
2029         class_body
2030                 {
2031                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2032                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2033
2034                   end_class_declaration (1);
2035
2036                   /* Now we can craft the new expression */
2037                   $$ = build_new_invocation (id, $4);
2038
2039                   /* Note that we can't possibly be here if
2040                      `class_type' is an interface (in which case the
2041                      anonymous class extends Object and implements
2042                      `class_type', hence its constructor can't have
2043                      arguments.) */
2044
2045                   /* Otherwise, the innerclass must feature a
2046                      constructor matching `argument_list'. Anonymous
2047                      classes are a bit special: it's impossible to
2048                      define constructor for them, hence constructors
2049                      must be generated following the hints provided by
2050                      the `new' expression. Whether a super constructor
2051                      of that nature exists or not is to be verified
2052                      later on in verify_constructor_super.
2053
2054                      It's during the expansion of a `new' statement
2055                      refering to an anonymous class that a ctor will
2056                      be generated for the anonymous class, with the
2057                      right arguments. */
2058
2059                 }
2060 |       NEW_TK class_type OP_TK CP_TK
2061                 { create_anonymous_class ($1.location, $2); }
2062         class_body
2063                 {
2064                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2065                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2066
2067                   end_class_declaration (1);
2068
2069                   /* Now we can craft the new expression. The
2070                      statement doesn't need to be remember so that a
2071                      constructor can be generated, since its signature
2072                      is already known. */
2073                   $$ = build_new_invocation (id, NULL_TREE);
2074                 }
2075 ;
2076
2077 something_dot_new:              /* Added, not part of the specs. */
2078         name DOT_TK NEW_TK
2079                 { $$ = $1; }
2080 |       primary DOT_TK NEW_TK
2081                 { $$ = $1; }
2082 ;
2083
2084 argument_list:
2085         expression
2086                 {
2087                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2088                   ctxp->formal_parameter_number = 1;
2089                 }
2090 |       argument_list C_TK expression
2091                 {
2092                   ctxp->formal_parameter_number += 1;
2093                   $$ = tree_cons (NULL_TREE, $3, $1);
2094                 }
2095 |       argument_list C_TK error
2096                 {yyerror ("Missing term"); RECOVER;}
2097 ;
2098
2099 array_creation_expression:
2100         NEW_TK primitive_type dim_exprs
2101                 { $$ = build_newarray_node ($2, $3, 0); }
2102 |       NEW_TK class_or_interface_type dim_exprs
2103                 { $$ = build_newarray_node ($2, $3, 0); }
2104 |       NEW_TK primitive_type dim_exprs dims
2105                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2106 |       NEW_TK class_or_interface_type dim_exprs dims
2107                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2108         /* Added, JDK1.1 anonymous array. Initial documentation rule
2109            modified */
2110 |       NEW_TK class_or_interface_type dims array_initializer
2111                 {
2112                   char *sig;
2113                   int osb = pop_current_osb (ctxp);
2114                   while (osb--)
2115                     obstack_grow (&temporary_obstack, "[]", 2);
2116                   obstack_1grow (&temporary_obstack, '\0');
2117                   sig = obstack_finish (&temporary_obstack);
2118                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2119                               $2, get_identifier (sig), $4);
2120                 }
2121 |       NEW_TK primitive_type dims array_initializer
2122                 {
2123                   int osb = pop_current_osb (ctxp);
2124                   tree type = $2;
2125                   while (osb--)
2126                     type = build_java_array_type (type, -1);
2127                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2128                               build_pointer_type (type), NULL_TREE, $4);
2129                 }
2130 |       NEW_TK error CSB_TK
2131                 {yyerror ("'[' expected"); DRECOVER ("]");}
2132 |       NEW_TK error OSB_TK
2133                 {yyerror ("']' expected"); RECOVER;}
2134 ;
2135
2136 dim_exprs:
2137         dim_expr
2138                 { $$ = build_tree_list (NULL_TREE, $1); }
2139 |       dim_exprs dim_expr
2140                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2141 ;
2142
2143 dim_expr:
2144         OSB_TK expression CSB_TK
2145                 {
2146                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2147                     {
2148                       $2 = build_wfl_node ($2);
2149                       TREE_TYPE ($2) = NULL_TREE;
2150                     }
2151                   EXPR_WFL_LINECOL ($2) = $1.location;
2152                   $$ = $2;
2153                 }
2154 |       OSB_TK expression error
2155                 {yyerror ("']' expected"); RECOVER;}
2156 |       OSB_TK error
2157                 {
2158                   yyerror ("Missing term");
2159                   yyerror ("']' expected");
2160                   RECOVER;
2161                 }
2162 ;
2163
2164 dims:
2165         OSB_TK CSB_TK
2166                 {
2167                   int allocate = 0;
2168                   /* If not initialized, allocate memory for the osb
2169                      numbers stack */
2170                   if (!ctxp->osb_limit)
2171                     {
2172                       allocate = ctxp->osb_limit = 32;
2173                       ctxp->osb_depth = -1;
2174                     }
2175                   /* If capacity overflown, reallocate a bigger chunk */
2176                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2177                     allocate = ctxp->osb_limit << 1;
2178
2179                   if (allocate)
2180                     {
2181                       allocate *= sizeof (int);
2182                       if (ctxp->osb_number)
2183                         ctxp->osb_number = xrealloc (ctxp->osb_number,
2184                                                      allocate);
2185                       else
2186                         ctxp->osb_number = xmalloc (allocate);
2187                     }
2188                   ctxp->osb_depth++;
2189                   CURRENT_OSB (ctxp) = 1;
2190                 }
2191 |       dims OSB_TK CSB_TK
2192                 { CURRENT_OSB (ctxp)++; }
2193 |       dims OSB_TK error
2194                 { yyerror ("']' expected"); RECOVER;}
2195 ;
2196
2197 field_access:
2198         primary DOT_TK identifier
2199                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2200                 /*  FIXME - REWRITE TO:
2201                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2202 |       SUPER_TK DOT_TK identifier
2203                 {
2204                   tree super_wfl = build_wfl_node (super_identifier_node);
2205                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
2206                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2207                 }
2208 |       SUPER_TK error
2209                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2210 ;
2211
2212 method_invocation:
2213         name OP_TK CP_TK
2214                 { $$ = build_method_invocation ($1, NULL_TREE); }
2215 |       name OP_TK argument_list CP_TK
2216                 { $$ = build_method_invocation ($1, $3); }
2217 |       primary DOT_TK identifier OP_TK CP_TK
2218                 {
2219                   if (TREE_CODE ($1) == THIS_EXPR)
2220                     $$ = build_this_super_qualified_invocation
2221                       (1, $3, NULL_TREE, 0, $2.location);
2222                   else
2223                     {
2224                       tree invok = build_method_invocation ($3, NULL_TREE);
2225                       $$ = make_qualified_primary ($1, invok, $2.location);
2226                     }
2227                 }
2228 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2229                 {
2230                   if (TREE_CODE ($1) == THIS_EXPR)
2231                     $$ = build_this_super_qualified_invocation
2232                       (1, $3, $5, 0, $2.location);
2233                   else
2234                     {
2235                       tree invok = build_method_invocation ($3, $5);
2236                       $$ = make_qualified_primary ($1, invok, $2.location);
2237                     }
2238                 }
2239 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2240                 {
2241                   $$ = build_this_super_qualified_invocation
2242                     (0, $3, NULL_TREE, $1.location, $2.location);
2243                 }
2244 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2245                 {
2246                   $$ = build_this_super_qualified_invocation
2247                     (0, $3, $5, $1.location, $2.location);
2248                 }
2249         /* Screws up thing. I let it here until I'm convinced it can
2250            be removed. FIXME
2251 |       primary DOT_TK error
2252                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2253 |       SUPER_TK DOT_TK error CP_TK
2254                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2255 |       SUPER_TK DOT_TK error DOT_TK
2256                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2257 ;
2258
2259 array_access:
2260         name OSB_TK expression CSB_TK
2261                 { $$ = build_array_ref ($2.location, $1, $3); }
2262 |       primary_no_new_array OSB_TK expression CSB_TK
2263                 { $$ = build_array_ref ($2.location, $1, $3); }
2264 |       name OSB_TK error
2265                 {
2266                   yyerror ("Missing term and ']' expected");
2267                   DRECOVER(array_access);
2268                 }
2269 |       name OSB_TK expression error
2270                 {
2271                   yyerror ("']' expected");
2272                   DRECOVER(array_access);
2273                 }
2274 |       primary_no_new_array OSB_TK error
2275                 {
2276                   yyerror ("Missing term and ']' expected");
2277                   DRECOVER(array_access);
2278                 }
2279 |       primary_no_new_array OSB_TK expression error
2280                 {
2281                   yyerror ("']' expected");
2282                   DRECOVER(array_access);
2283                 }
2284 ;
2285
2286 postfix_expression:
2287         primary
2288 |       name
2289 |       post_increment_expression
2290 |       post_decrement_expression
2291 ;
2292
2293 post_increment_expression:
2294         postfix_expression INCR_TK
2295                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2296 ;
2297
2298 post_decrement_expression:
2299         postfix_expression DECR_TK
2300                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2301 ;
2302
2303 trap_overflow_corner_case:
2304         pre_increment_expression
2305 |       pre_decrement_expression
2306 |       PLUS_TK unary_expression
2307                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2308 |       unary_expression_not_plus_minus
2309 |       PLUS_TK error
2310                 {yyerror ("Missing term"); RECOVER}
2311 ;
2312
2313 unary_expression:
2314         trap_overflow_corner_case
2315                 {
2316                   error_if_numeric_overflow ($1);
2317                   $$ = $1;
2318                 }
2319 |       MINUS_TK trap_overflow_corner_case
2320                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2321 |       MINUS_TK error
2322                 {yyerror ("Missing term"); RECOVER}
2323 ;
2324
2325 pre_increment_expression:
2326         INCR_TK unary_expression
2327                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2328 |       INCR_TK error
2329                 {yyerror ("Missing term"); RECOVER}
2330 ;
2331
2332 pre_decrement_expression:
2333         DECR_TK unary_expression
2334                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2335 |       DECR_TK error
2336                 {yyerror ("Missing term"); RECOVER}
2337 ;
2338
2339 unary_expression_not_plus_minus:
2340         postfix_expression
2341 |       NOT_TK unary_expression
2342                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2343 |       NEG_TK unary_expression
2344                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2345 |       cast_expression
2346 |       NOT_TK error
2347                 {yyerror ("Missing term"); RECOVER}
2348 |       NEG_TK error
2349                 {yyerror ("Missing term"); RECOVER}
2350 ;
2351
2352 cast_expression:                /* Error handling here is potentially weak */
2353         OP_TK primitive_type dims CP_TK unary_expression
2354                 {
2355                   tree type = $2;
2356                   int osb = pop_current_osb (ctxp);
2357                   while (osb--)
2358                     type = build_java_array_type (type, -1);
2359                   $$ = build_cast ($1.location, type, $5);
2360                 }
2361 |       OP_TK primitive_type CP_TK unary_expression
2362                 { $$ = build_cast ($1.location, $2, $4); }
2363 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2364                 { $$ = build_cast ($1.location, $2, $4); }
2365 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2366                 {
2367                   const char *ptr;
2368                   int osb = pop_current_osb (ctxp);
2369                   obstack_grow (&temporary_obstack,
2370                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2371                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2372                   while (osb--)
2373                     obstack_grow (&temporary_obstack, "[]", 2);
2374                   obstack_1grow (&temporary_obstack, '\0');
2375                   ptr = obstack_finish (&temporary_obstack);
2376                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2377                   $$ = build_cast ($1.location, $2, $5);
2378                 }
2379 |       OP_TK primitive_type OSB_TK error
2380                 {yyerror ("']' expected, invalid type expression");}
2381 |       OP_TK error
2382                 {
2383                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2384                   RECOVER;
2385                 }
2386 |       OP_TK primitive_type dims CP_TK error
2387                 {yyerror ("Missing term"); RECOVER;}
2388 |       OP_TK primitive_type CP_TK error
2389                 {yyerror ("Missing term"); RECOVER;}
2390 |       OP_TK name dims CP_TK error
2391                 {yyerror ("Missing term"); RECOVER;}
2392 ;
2393
2394 multiplicative_expression:
2395         unary_expression
2396 |       multiplicative_expression MULT_TK unary_expression
2397                 {
2398                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2399                                     $2.location, $1, $3);
2400                 }
2401 |       multiplicative_expression DIV_TK unary_expression
2402                 {
2403                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2404                                     $1, $3);
2405                 }
2406 |       multiplicative_expression REM_TK unary_expression
2407                 {
2408                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2409                                     $1, $3);
2410                 }
2411 |       multiplicative_expression MULT_TK error
2412                 {yyerror ("Missing term"); RECOVER;}
2413 |       multiplicative_expression DIV_TK error
2414                 {yyerror ("Missing term"); RECOVER;}
2415 |       multiplicative_expression REM_TK error
2416                 {yyerror ("Missing term"); RECOVER;}
2417 ;
2418
2419 additive_expression:
2420         multiplicative_expression
2421 |       additive_expression PLUS_TK multiplicative_expression
2422                 {
2423                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2424                                     $1, $3);
2425                 }
2426 |       additive_expression MINUS_TK multiplicative_expression
2427                 {
2428                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2429                                     $1, $3);
2430                 }
2431 |       additive_expression PLUS_TK error
2432                 {yyerror ("Missing term"); RECOVER;}
2433 |       additive_expression MINUS_TK error
2434                 {yyerror ("Missing term"); RECOVER;}
2435 ;
2436
2437 shift_expression:
2438         additive_expression
2439 |       shift_expression LS_TK additive_expression
2440                 {
2441                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2442                                     $1, $3);
2443                 }
2444 |       shift_expression SRS_TK additive_expression
2445                 {
2446                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2447                                     $1, $3);
2448                 }
2449 |       shift_expression ZRS_TK additive_expression
2450                 {
2451                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2452                                     $1, $3);
2453                 }
2454 |       shift_expression LS_TK error
2455                 {yyerror ("Missing term"); RECOVER;}
2456 |       shift_expression SRS_TK error
2457                 {yyerror ("Missing term"); RECOVER;}
2458 |       shift_expression ZRS_TK error
2459                 {yyerror ("Missing term"); RECOVER;}
2460 ;
2461
2462 relational_expression:
2463         shift_expression
2464 |       relational_expression LT_TK shift_expression
2465                 {
2466                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2467                                     $1, $3);
2468                 }
2469 |       relational_expression GT_TK shift_expression
2470                 {
2471                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2472                                     $1, $3);
2473                 }
2474 |       relational_expression LTE_TK shift_expression
2475                 {
2476                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2477                                     $1, $3);
2478                 }
2479 |       relational_expression GTE_TK shift_expression
2480                 {
2481                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2482                                     $1, $3);
2483                 }
2484 |       relational_expression INSTANCEOF_TK reference_type
2485                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2486 |       relational_expression LT_TK error
2487                 {yyerror ("Missing term"); RECOVER;}
2488 |       relational_expression GT_TK error
2489                 {yyerror ("Missing term"); RECOVER;}
2490 |       relational_expression LTE_TK error
2491                 {yyerror ("Missing term"); RECOVER;}
2492 |       relational_expression GTE_TK error
2493                 {yyerror ("Missing term"); RECOVER;}
2494 |       relational_expression INSTANCEOF_TK error
2495                 {yyerror ("Invalid reference type"); RECOVER;}
2496 ;
2497
2498 equality_expression:
2499         relational_expression
2500 |       equality_expression EQ_TK relational_expression
2501                 {
2502                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2503                                     $1, $3);
2504                 }
2505 |       equality_expression NEQ_TK relational_expression
2506                 {
2507                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2508                                     $1, $3);
2509                 }
2510 |       equality_expression EQ_TK error
2511                 {yyerror ("Missing term"); RECOVER;}
2512 |       equality_expression NEQ_TK error
2513                 {yyerror ("Missing term"); RECOVER;}
2514 ;
2515
2516 and_expression:
2517         equality_expression
2518 |       and_expression AND_TK equality_expression
2519                 {
2520                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2521                                     $1, $3);
2522                 }
2523 |       and_expression AND_TK error
2524                 {yyerror ("Missing term"); RECOVER;}
2525 ;
2526
2527 exclusive_or_expression:
2528         and_expression
2529 |       exclusive_or_expression XOR_TK and_expression
2530                 {
2531                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2532                                     $1, $3);
2533                 }
2534 |       exclusive_or_expression XOR_TK error
2535                 {yyerror ("Missing term"); RECOVER;}
2536 ;
2537
2538 inclusive_or_expression:
2539         exclusive_or_expression
2540 |       inclusive_or_expression OR_TK exclusive_or_expression
2541                 {
2542                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2543                                     $1, $3);
2544                 }
2545 |       inclusive_or_expression OR_TK error
2546                 {yyerror ("Missing term"); RECOVER;}
2547 ;
2548
2549 conditional_and_expression:
2550         inclusive_or_expression
2551 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2552                 {
2553                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2554                                     $1, $3);
2555                 }
2556 |       conditional_and_expression BOOL_AND_TK error
2557                 {yyerror ("Missing term"); RECOVER;}
2558 ;
2559
2560 conditional_or_expression:
2561         conditional_and_expression
2562 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2563                 {
2564                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2565                                     $1, $3);
2566                 }
2567 |       conditional_or_expression BOOL_OR_TK error
2568                 {yyerror ("Missing term"); RECOVER;}
2569 ;
2570
2571 conditional_expression:         /* Error handling here is weak */
2572         conditional_or_expression
2573 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2574                 {
2575                   $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2576                   EXPR_WFL_LINECOL ($$) = $2.location;
2577                 }
2578 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2579                 {
2580                   YYERROR_NOW;
2581                   yyerror ("Missing term");
2582                   DRECOVER (1);
2583                 }
2584 |       conditional_or_expression REL_QM_TK error
2585                 {yyerror ("Missing term"); DRECOVER (2);}
2586 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2587                 {yyerror ("Missing term"); DRECOVER (3);}
2588 ;
2589
2590 assignment_expression:
2591         conditional_expression
2592 |       assignment
2593 ;
2594
2595 assignment:
2596         left_hand_side assignment_operator assignment_expression
2597                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2598 |       left_hand_side assignment_operator error
2599                 {
2600                   YYNOT_TWICE yyerror ("Missing term");
2601                   DRECOVER (assign);
2602                 }
2603 ;
2604
2605 left_hand_side:
2606         name
2607 |       field_access
2608 |       array_access
2609 ;
2610
2611 assignment_operator:
2612         ASSIGN_ANY_TK
2613 |       ASSIGN_TK
2614 ;
2615
2616 expression:
2617         assignment_expression
2618 ;
2619
2620 constant_expression:
2621         expression
2622 ;
2623
2624 %%
2625
2626 /* Helper function to retrieve an OSB count. Should be used when the
2627    `dims:' rule is being used.  */
2628
2629 static int
2630 pop_current_osb (struct parser_ctxt *ctxp)
2631 {
2632   int to_return;
2633
2634   if (ctxp->osb_depth < 0)
2635     abort ();
2636
2637   to_return = CURRENT_OSB (ctxp);
2638   ctxp->osb_depth--;
2639
2640   return to_return;
2641 }
2642
2643 \f
2644
2645 /* This section of the code deal with save/restoring parser contexts.
2646    Add mode documentation here. FIXME */
2647
2648 /* Helper function. Create a new parser context. With
2649    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2650    context is copied, otherwise, the new context is zeroed. The newly
2651    created context becomes the current one.  */
2652
2653 static void
2654 create_new_parser_context (int copy_from_previous)
2655 {
2656   struct parser_ctxt *new;
2657
2658   new = ggc_alloc (sizeof (struct parser_ctxt));
2659   if (copy_from_previous)
2660     {
2661       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2662       new->saved_data_ctx = 1;
2663     }
2664   else
2665     memset (new, 0, sizeof (struct parser_ctxt));
2666
2667   new->next = ctxp;
2668   ctxp = new;
2669 }
2670
2671 /* Create a new parser context and make it the current one. */
2672
2673 void
2674 java_push_parser_context (void)
2675 {
2676   create_new_parser_context (0);
2677 }
2678
2679 void
2680 java_pop_parser_context (int generate)
2681 {
2682   tree current;
2683   struct parser_ctxt *toFree, *next;
2684
2685   if (!ctxp)
2686     return;
2687
2688   toFree = ctxp;
2689   next = ctxp->next;
2690   if (next)
2691     {
2692       input_line = ctxp->lineno;
2693       current_class = ctxp->class_type;
2694     }
2695
2696   /* If the old and new lexers differ, then free the old one.  */
2697   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2698     java_destroy_lexer (ctxp->lexer);
2699
2700   /* Set the single import class file flag to 0 for the current list
2701      of imported things */
2702   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2703     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2704
2705   /* And restore those of the previous context */
2706   if ((ctxp = next))            /* Assignment is really meant here */
2707     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2708       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2709
2710   /* If we pushed a context to parse a class intended to be generated,
2711      we keep it so we can remember the class. What we could actually
2712      do is to just update a list of class names.  */
2713   if (generate)
2714     {
2715       toFree->next = ctxp_for_generation;
2716       ctxp_for_generation = toFree;
2717     }
2718 }
2719
2720 /* Create a parser context for the use of saving some global
2721    variables.  */
2722
2723 void
2724 java_parser_context_save_global (void)
2725 {
2726   if (!ctxp)
2727     {
2728       java_push_parser_context ();
2729       ctxp->saved_data_ctx = 1;
2730     }
2731
2732   /* If this context already stores data, create a new one suitable
2733      for data storage. */
2734   else if (ctxp->saved_data)
2735     create_new_parser_context (1);
2736
2737   ctxp->lineno = input_line;
2738   ctxp->class_type = current_class;
2739   ctxp->filename = input_filename;
2740   ctxp->function_decl = current_function_decl;
2741   ctxp->saved_data = 1;
2742 }
2743
2744 /* Restore some global variables from the previous context. Make the
2745    previous context the current one.  */
2746
2747 void
2748 java_parser_context_restore_global (void)
2749 {
2750   input_line = ctxp->lineno;
2751   current_class = ctxp->class_type;
2752   input_filename = ctxp->filename;
2753   if (wfl_operator)
2754     {
2755       tree s;
2756       BUILD_FILENAME_IDENTIFIER_NODE (s, input_filename);
2757       EXPR_WFL_FILENAME_NODE (wfl_operator) = s;
2758     }
2759   current_function_decl = ctxp->function_decl;
2760   ctxp->saved_data = 0;
2761   if (ctxp->saved_data_ctx)
2762     java_pop_parser_context (0);
2763 }
2764
2765 /* Suspend vital data for the current class/function being parsed so
2766    that an other class can be parsed. Used to let local/anonymous
2767    classes be parsed.  */
2768
2769 static void
2770 java_parser_context_suspend (void)
2771 {
2772   /* This makes debugging through java_debug_context easier */
2773   static const char *const name = "<inner buffer context>";
2774
2775   /* Duplicate the previous context, use it to save the globals we're
2776      interested in */
2777   create_new_parser_context (1);
2778   ctxp->function_decl = current_function_decl;
2779   ctxp->class_type = current_class;
2780
2781   /* Then create a new context which inherits all data from the
2782      previous one. This will be the new current context  */
2783   create_new_parser_context (1);
2784
2785   /* Help debugging */
2786   ctxp->next->filename = name;
2787 }
2788
2789 /* Resume vital data for the current class/function being parsed so
2790    that an other class can be parsed. Used to let local/anonymous
2791    classes be parsed.  The trick is the data storing file position
2792    informations must be restored to their current value, so parsing
2793    can resume as if no context was ever saved. */
2794
2795 static void
2796 java_parser_context_resume (void)
2797 {
2798   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2799   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2800   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2801
2802   /* We need to inherit the list of classes to complete/generate */
2803   restored->classd_list = old->classd_list;
2804   restored->class_list = old->class_list;
2805
2806   /* Restore the current class and function from the saver */
2807   current_class = saver->class_type;
2808   current_function_decl = saver->function_decl;
2809
2810   /* Retrive the restored context */
2811   ctxp = restored;
2812
2813   /* Re-installed the data for the parsing to carry on */
2814   memcpy (&ctxp->marker_begining, &old->marker_begining,
2815           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2816 }
2817
2818 /* Add a new anchor node to which all statement(s) initializing static
2819    and non static initialized upon declaration field(s) will be
2820    linked.  */
2821
2822 static void
2823 java_parser_context_push_initialized_field (void)
2824 {
2825   tree node;
2826
2827   node = build_tree_list (NULL_TREE, NULL_TREE);
2828   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2829   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2830
2831   node = build_tree_list (NULL_TREE, NULL_TREE);
2832   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2833   CPC_INITIALIZER_LIST (ctxp) = node;
2834
2835   node = build_tree_list (NULL_TREE, NULL_TREE);
2836   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2837   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2838 }
2839
2840 /* Pop the lists of initialized field. If this lists aren't empty,
2841    remember them so we can use it to create and populate the finit$
2842    or <clinit> functions. */
2843
2844 static void
2845 java_parser_context_pop_initialized_field (void)
2846 {
2847   tree stmts;
2848   tree class_type = TREE_TYPE (GET_CPC ());
2849
2850   if (CPC_INITIALIZER_LIST (ctxp))
2851     {
2852       stmts = CPC_INITIALIZER_STMT (ctxp);
2853       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2854       if (stmts && !java_error_count)
2855         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2856     }
2857
2858   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2859     {
2860       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2861       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2862         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2863       /* Keep initialization in order to enforce 8.5 */
2864       if (stmts && !java_error_count)
2865         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2866     }
2867
2868   /* JDK 1.1 instance initializers */
2869   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2870     {
2871       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2872       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2873         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2874       if (stmts && !java_error_count)
2875         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2876     }
2877 }
2878
2879 static tree
2880 reorder_static_initialized (tree list)
2881 {
2882   /* We have to keep things in order. The alias initializer have to
2883      come first, then the initialized regular field, in reverse to
2884      keep them in lexical order. */
2885   tree marker, previous = NULL_TREE;
2886   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2887     if (TREE_CODE (marker) == TREE_LIST
2888         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2889       break;
2890
2891   /* No static initialized, the list is fine as is */
2892   if (!previous)
2893     list = TREE_CHAIN (marker);
2894
2895   /* No marker? reverse the whole list */
2896   else if (!marker)
2897     list = nreverse (list);
2898
2899   /* Otherwise, reverse what's after the marker and the new reordered
2900      sublist will replace the marker. */
2901   else
2902     {
2903       TREE_CHAIN (previous) = NULL_TREE;
2904       list = nreverse (list);
2905       list = chainon (TREE_CHAIN (marker), list);
2906     }
2907   return list;
2908 }
2909
2910 /* Helper functions to dump the parser context stack.  */
2911
2912 #define TAB_CONTEXT(C) \
2913   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2914
2915 static void
2916 java_debug_context_do (int tab)
2917 {
2918   struct parser_ctxt *copy = ctxp;
2919   while (copy)
2920     {
2921       TAB_CONTEXT (tab);
2922       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2923       TAB_CONTEXT (tab);
2924       fprintf (stderr, "filename: %s\n", copy->filename);
2925       TAB_CONTEXT (tab);
2926       fprintf (stderr, "lineno: %d\n", copy->lineno);
2927       TAB_CONTEXT (tab);
2928       fprintf (stderr, "package: %s\n",
2929                (copy->package ?
2930                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2931       TAB_CONTEXT (tab);
2932       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2933       TAB_CONTEXT (tab);
2934       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2935       copy = copy->next;
2936       tab += 2;
2937     }
2938 }
2939
2940 /* Dump the stacked up parser contexts. Intended to be called from a
2941    debugger.  */
2942
2943 void
2944 java_debug_context (void)
2945 {
2946   java_debug_context_do (0);
2947 }
2948
2949 \f
2950
2951 /* Flag for the error report routine to issue the error the first time
2952    it's called (overriding the default behavior which is to drop the
2953    first invocation and honor the second one, taking advantage of a
2954    richer context.  */
2955 static int force_error = 0;
2956
2957 /* Reporting an constructor invocation error.  */
2958 static void
2959 parse_ctor_invocation_error (void)
2960 {
2961   if (DECL_CONSTRUCTOR_P (current_function_decl))
2962     yyerror ("Constructor invocation must be first thing in a constructor");
2963   else
2964     yyerror ("Only constructors can invoke constructors");
2965 }
2966
2967 /* Reporting JDK1.1 features not implemented.  */
2968
2969 static tree
2970 parse_jdk1_1_error (const char *msg)
2971 {
2972   sorry (": `%s' JDK1.1(TM) feature", msg);
2973   java_error_count++;
2974   return empty_stmt_node;
2975 }
2976
2977 static int do_warning = 0;
2978
2979 void
2980 yyerror (const char *msg)
2981 {
2982   static java_lc elc;
2983   static int  prev_lineno;
2984   static const char *prev_msg;
2985
2986   int save_lineno;
2987   char *remainder, *code_from_source;
2988
2989   if (!force_error && prev_lineno == input_line)
2990     return;
2991
2992   /* Save current error location but report latter, when the context is
2993      richer.  */
2994   if (ctxp->java_error_flag == 0)
2995     {
2996       ctxp->java_error_flag = 1;
2997       elc = ctxp->elc;
2998       /* Do something to use the previous line if we're reaching the
2999          end of the file... */
3000 #ifdef VERBOSE_SKELETON
3001       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3002 #endif
3003       return;
3004     }
3005
3006   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3007   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3008     return;
3009
3010   ctxp->java_error_flag = 0;
3011   if (do_warning)
3012     java_warning_count++;
3013   else
3014     java_error_count++;
3015
3016   if (elc.col == 0 && msg && msg[1] == ';')
3017     {
3018       elc.col  = ctxp->p_line->char_col-1;
3019       elc.line = ctxp->p_line->lineno;
3020     }
3021
3022   save_lineno = input_line;
3023   prev_lineno = input_line = elc.line;
3024   prev_msg = msg;
3025
3026   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3027   obstack_grow0 (&temporary_obstack,
3028                  code_from_source, strlen (code_from_source));
3029   remainder = obstack_finish (&temporary_obstack);
3030   if (do_warning)
3031     warning ("%s.\n%s", msg, remainder);
3032   else
3033     error ("%s.\n%s", msg, remainder);
3034
3035   /* This allow us to cheaply avoid an extra 'Invalid expression
3036      statement' error report when errors have been already reported on
3037      the same line. This occurs when we report an error but don't have
3038      a synchronization point other than ';', which
3039      expression_statement is the only one to take care of.  */
3040   ctxp->prevent_ese = input_line = save_lineno;
3041 }
3042
3043 static void
3044 issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
3045 {
3046   const char *saved, *saved_input_filename;
3047   char buffer [4096];
3048   vsprintf (buffer, msg, ap);
3049   force_error = 1;
3050
3051   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3052   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3053                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3054
3055   /* We have a CL, that's a good reason for using it if it contains data */
3056   saved = ctxp->filename;
3057   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3058     ctxp->filename = EXPR_WFL_FILENAME (cl);
3059   saved_input_filename = input_filename;
3060   input_filename = ctxp->filename;
3061   java_error (NULL);
3062   java_error (buffer);
3063   ctxp->filename = saved;
3064   input_filename = saved_input_filename;
3065   force_error = 0;
3066 }
3067
3068 /* Issue an error message at a current source line CL */
3069
3070 void
3071 parse_error_context (tree cl, const char *msg, ...)
3072 {
3073   va_list ap;
3074   va_start (ap, msg);
3075   issue_warning_error_from_context (cl, msg, ap);
3076   va_end (ap);
3077 }
3078
3079 /* Issue a warning at a current source line CL */
3080
3081 static void
3082 parse_warning_context (tree cl, const char *msg, ...)
3083 {
3084   va_list ap;
3085   va_start (ap, msg);
3086
3087   force_error = do_warning = 1;
3088   issue_warning_error_from_context (cl, msg, ap);
3089   do_warning = force_error = 0;
3090   va_end (ap);
3091 }
3092
3093 static tree
3094 find_expr_with_wfl (tree node)
3095 {
3096   while (node)
3097     {
3098       char code;
3099       tree to_return;
3100
3101       switch (TREE_CODE (node))
3102         {
3103         case BLOCK:
3104           node = BLOCK_EXPR_BODY (node);
3105           continue;
3106
3107         case COMPOUND_EXPR:
3108           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3109           if (to_return)
3110             return to_return;
3111           node = TREE_OPERAND (node, 1);
3112           continue;
3113
3114         case LOOP_EXPR:
3115           node = TREE_OPERAND (node, 0);
3116           continue;
3117
3118         case LABELED_BLOCK_EXPR:
3119           node = TREE_OPERAND (node, 1);
3120           continue;
3121
3122         default:
3123           code = TREE_CODE_CLASS (TREE_CODE (node));
3124           if (((code == '1') || (code == '2') || (code == 'e'))
3125               && EXPR_WFL_LINECOL (node))
3126             return node;
3127           return NULL_TREE;
3128         }
3129     }
3130   return NULL_TREE;
3131 }
3132
3133 /* Issue a missing return statement error. Uses METHOD to figure the
3134    last line of the method the error occurs in.  */
3135
3136 static void
3137 missing_return_error (tree method)
3138 {
3139   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3140   parse_error_context (wfl_operator, "Missing return statement");
3141 }
3142
3143 /* Issue an unreachable statement error. From NODE, find the next
3144    statement to report appropriately.  */
3145 static void
3146 unreachable_stmt_error (tree node)
3147 {
3148   /* Browse node to find the next expression node that has a WFL. Use
3149      the location to report the error */
3150   if (TREE_CODE (node) == COMPOUND_EXPR)
3151     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3152   else
3153     node = find_expr_with_wfl (node);
3154
3155   if (node)
3156     {
3157       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3158       parse_error_context (wfl_operator, "Unreachable statement");
3159     }
3160   else
3161     abort ();
3162 }
3163
3164 int
3165 java_report_errors (void)
3166 {
3167   if (java_error_count)
3168     fprintf (stderr, "%d error%s",
3169              java_error_count, (java_error_count == 1 ? "" : "s"));
3170   if (java_warning_count)
3171     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3172              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3173   if (java_error_count || java_warning_count)
3174     putc ('\n', stderr);
3175   return java_error_count;
3176 }
3177
3178 static char *
3179 java_accstring_lookup (int flags)
3180 {
3181   static char buffer [80];
3182 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3183
3184   /* Access modifier looked-up first for easier report on forbidden
3185      access. */
3186   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3187   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3188   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3189   if (flags & ACC_STATIC) COPY_RETURN ("static");
3190   if (flags & ACC_FINAL) COPY_RETURN ("final");
3191   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3192   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3193   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3194   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3195   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3196   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3197
3198   buffer [0] = '\0';
3199   return buffer;
3200 #undef COPY_RETURN
3201 }
3202
3203 /* Issuing error messages upon redefinition of classes, interfaces or
3204    variables. */
3205
3206 static void
3207 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3208 {
3209   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3210                        context, IDENTIFIER_POINTER (id),
3211                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3212   /* Here we should point out where its redefined. It's a unicode. FIXME */
3213 }
3214
3215 static void
3216 variable_redefinition_error (tree context, tree name, tree type, int line)
3217 {
3218   const char *type_name;
3219
3220   /* Figure a proper name for type. We might haven't resolved it */
3221   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3222     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3223   else
3224     type_name = lang_printable_name (type, 0);
3225
3226   parse_error_context (context,
3227                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3228                        IDENTIFIER_POINTER (name),
3229                        type_name, IDENTIFIER_POINTER (name), line);
3230 }
3231
3232 /* If ANAME is terminated with `[]', it indicates an array. This
3233    function returns the number of `[]' found and if this number is
3234    greater than zero, it extracts the array type name and places it in
3235    the node pointed to by TRIMMED unless TRIMMED is null.  */
3236
3237 static int
3238 build_type_name_from_array_name (tree aname, tree *trimmed)
3239 {
3240   const char *name = IDENTIFIER_POINTER (aname);
3241   int len = IDENTIFIER_LENGTH (aname);
3242   int array_dims;
3243
3244   STRING_STRIP_BRACKETS (name, len, array_dims);
3245
3246   if (array_dims && trimmed)
3247     *trimmed = get_identifier_with_length (name, len);
3248
3249   return array_dims;
3250 }
3251
3252 static tree
3253 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3254 {
3255   int more_dims = 0;
3256
3257   /* Eventually get more dims */
3258   more_dims = build_type_name_from_array_name (name, &name);
3259
3260   /* If we have, then craft a new type for this variable */
3261   if (more_dims)
3262     {
3263       tree save = type;
3264
3265       /* If we have a pointer, use its type */
3266       if (TREE_CODE (type) == POINTER_TYPE)
3267         type = TREE_TYPE (type);
3268
3269       /* Building the first dimension of a primitive type uses this
3270          function */
3271       if (JPRIMITIVE_TYPE_P (type))
3272         {
3273           type = build_java_array_type (type, -1);
3274           more_dims--;
3275         }
3276       /* Otherwise, if we have a WFL for this type, use it (the type
3277          is already an array on an unresolved type, and we just keep
3278          on adding dimensions) */
3279       else if (type_wfl)
3280         {
3281           type = type_wfl;
3282           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3283                                                         NULL);
3284         }
3285
3286       /* Add all the dimensions */
3287       while (more_dims--)
3288         type = build_unresolved_array_type (type);
3289
3290       /* The type may have been incomplete in the first place */
3291       if (type_wfl)
3292         type = obtain_incomplete_type (type);
3293     }
3294
3295   if (ret_name)
3296     *ret_name = name;
3297   return type;
3298 }
3299
3300 /* Build something that the type identifier resolver will identify as
3301    being an array to an unresolved type. TYPE_WFL is a WFL on a
3302    identifier. */
3303
3304 static tree
3305 build_unresolved_array_type (tree type_or_wfl)
3306 {
3307   const char *ptr;
3308   tree wfl;
3309
3310   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3311      just create a array type */
3312   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3313     return build_java_array_type (type_or_wfl, -1);
3314
3315   obstack_grow (&temporary_obstack,
3316                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3317                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3318   obstack_grow0 (&temporary_obstack, "[]", 2);
3319   ptr = obstack_finish (&temporary_obstack);
3320   wfl = build_expr_wfl (get_identifier (ptr),
3321                         EXPR_WFL_FILENAME (type_or_wfl),
3322                         EXPR_WFL_LINENO (type_or_wfl),
3323                         EXPR_WFL_COLNO (type_or_wfl));
3324   /* Re-install the existing qualifications so that the type can be
3325      resolved properly. */
3326   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3327   return wfl;
3328 }
3329
3330 static void
3331 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3332 {
3333   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3334     parse_error_context (wfl, "Interface `%s' repeated",
3335                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3336 }
3337
3338 /* Bulk of common class/interface checks. Return 1 if an error was
3339    encountered. TAG is 0 for a class, 1 for an interface.  */
3340
3341 static int
3342 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3343                                 tree qualified_name, tree decl, tree cl)
3344 {
3345   tree node;
3346   int sca = 0;                  /* Static class allowed */
3347   int icaf = 0;                 /* Inner class allowed flags */
3348   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3349
3350   if (!quiet_flag)
3351     fprintf (stderr, " %s%s %s",
3352              (CPC_INNER_P () ? "inner" : ""),
3353              (is_interface ? "interface" : "class"),
3354              IDENTIFIER_POINTER (qualified_name));
3355
3356   /* Scope of an interface/class type name:
3357        - Can't be imported by a single type import
3358        - Can't already exists in the package */
3359   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3360       && (node = find_name_in_single_imports (raw_name))
3361       && !CPC_INNER_P ())
3362     {
3363       parse_error_context
3364         (cl, "%s name `%s' clashes with imported type `%s'",
3365          (is_interface ? "Interface" : "Class"),
3366          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3367       return 1;
3368     }
3369   if (decl && CLASS_COMPLETE_P (decl))
3370     {
3371       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3372                                    qualified_name, decl, cl);
3373       return 1;
3374     }
3375
3376   if (check_inner_class_redefinition (raw_name, cl))
3377     return 1;
3378
3379   /* If public, file name should match class/interface name, except
3380      when dealing with an inner class */
3381   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3382     {
3383       const char *f;
3384
3385       for (f = &input_filename [strlen (input_filename)];
3386            f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3387            f--)
3388         ;
3389       if (IS_DIR_SEPARATOR (f[0]))
3390         f++;
3391       if (strncmp (IDENTIFIER_POINTER (raw_name),
3392                    f , IDENTIFIER_LENGTH (raw_name)) ||
3393           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3394         parse_error_context
3395           (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3396                              (is_interface ? "interface" : "class"),
3397                              IDENTIFIER_POINTER (qualified_name),
3398                              IDENTIFIER_POINTER (raw_name));
3399     }
3400
3401   /* Static classes can be declared only in top level classes. Note:
3402      once static, a inner class is a top level class. */
3403   if (flags & ACC_STATIC)
3404     {
3405       /* Catch the specific error of declaring an class inner class
3406          with no toplevel enclosing class. Prevent check_modifiers from
3407          complaining a second time */
3408       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3409         {
3410           parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3411                                IDENTIFIER_POINTER (qualified_name));
3412           sca = ACC_STATIC;
3413         }
3414       /* Else, in the context of a top-level class declaration, let
3415          `check_modifiers' do its job, otherwise, give it a go */
3416       else
3417         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3418     }
3419
3420   /* Inner classes can be declared private or protected
3421      within their enclosing classes. */
3422   if (CPC_INNER_P ())
3423     {
3424       /* A class which is local to a block can't be public, private,
3425          protected or static. But it is created final, so allow this
3426          one. */
3427       if (current_function_decl)
3428         icaf = sca = uaaf = ACC_FINAL;
3429       else
3430         {
3431           check_modifiers_consistency (flags);
3432           icaf = ACC_PROTECTED;
3433           if (! CLASS_INTERFACE (GET_CPC ()))
3434             icaf |= ACC_PRIVATE;
3435         }
3436     }
3437
3438   if (is_interface)
3439     {
3440       if (CPC_INNER_P ())
3441         uaaf = INTERFACE_INNER_MODIFIERS;
3442       else
3443         uaaf = INTERFACE_MODIFIERS;
3444
3445       check_modifiers ("Illegal modifier `%s' for interface declaration",
3446                        flags, uaaf);
3447     }
3448   else
3449     check_modifiers ((current_function_decl ?
3450                       "Illegal modifier `%s' for local class declaration" :
3451                       "Illegal modifier `%s' for class declaration"),
3452                      flags, uaaf|sca|icaf);
3453   return 0;
3454 }
3455
3456 /* Construct a nested class name.  If the final component starts with
3457    a digit, return true.  Otherwise return false.  */
3458 static int
3459 make_nested_class_name (tree cpc_list)
3460 {
3461   tree name;
3462
3463   if (!cpc_list)
3464     return 0;
3465
3466   make_nested_class_name (TREE_CHAIN (cpc_list));
3467
3468   /* Pick the qualified name when dealing with the first upmost
3469      enclosing class */
3470   name = (TREE_CHAIN (cpc_list)
3471           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3472   obstack_grow (&temporary_obstack,
3473                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3474   obstack_1grow (&temporary_obstack, '$');
3475
3476   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3477 }
3478
3479 /* Can't redefine a class already defined in an earlier scope. */
3480
3481 static int
3482 check_inner_class_redefinition (tree raw_name, tree cl)
3483 {
3484   tree scope_list;
3485
3486   for (scope_list = GET_CPC_LIST (); scope_list;
3487        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3488     if (raw_name == GET_CPC_UN_NODE (scope_list))
3489       {
3490         parse_error_context
3491           (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",
3492            IDENTIFIER_POINTER (raw_name));
3493         return 1;
3494       }
3495   return 0;
3496 }
3497
3498 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3499    we remember ENCLOSING and SUPER.  */
3500
3501 static tree
3502 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3503                      tree *super, tree class_type)
3504 {
3505   tree local_enclosing = *enclosing;
3506   tree local_super = NULL_TREE;
3507
3508   while (local_enclosing)
3509     {
3510       tree intermediate, decl;
3511
3512       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3513         local_enclosing;
3514
3515       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3516         return decl;
3517
3518       intermediate = local_enclosing;
3519       /* Explore enclosing contexts. */
3520       while (INNER_CLASS_DECL_P (intermediate))
3521         {
3522           intermediate = DECL_CONTEXT (intermediate);
3523           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3524             return decl;
3525         }
3526
3527       /* Now go to the upper classes, bail out if necessary.  We will
3528          analyze the returned SUPER and act accordingly (see
3529          do_resolve_class).  */
3530       if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3531           || TREE_TYPE (local_enclosing) == void_type_node)
3532         {
3533           parse_error_context (cl, "Qualifier must be a reference");
3534           local_enclosing = NULL_TREE;
3535           break;
3536         }
3537       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3538       if (!local_super || local_super == object_type_node)
3539         break;
3540
3541       if (TREE_CODE (local_super) == POINTER_TYPE)
3542         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3543       else
3544         local_super = TYPE_NAME (local_super);
3545
3546       /* We may not have checked for circular inheritance yet, so do so
3547          here to prevent an infinite loop. */
3548       if (htab_find (circularity_hash, local_super) != NULL)
3549         {
3550           if (!cl)
3551             cl = lookup_cl (local_enclosing);
3552
3553           parse_error_context
3554             (cl, "Cyclic inheritance involving %s",
3555              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3556           local_enclosing = NULL_TREE;
3557         }
3558       else
3559         local_enclosing = local_super;
3560     }
3561
3562   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3563   *super = local_super;
3564   *enclosing = local_enclosing;
3565
3566   return NULL_TREE;
3567 }
3568
3569 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3570    qualified. */
3571
3572 static tree
3573 find_as_inner_class (tree enclosing, tree name, tree cl)
3574 {
3575   tree qual, to_return;
3576   if (!enclosing)
3577     return NULL_TREE;
3578
3579   name = TYPE_NAME (name);
3580
3581   /* First search: within the scope of `enclosing', search for name */
3582   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3583     qual = EXPR_WFL_QUALIFICATION (cl);
3584   else if (cl)
3585     qual = build_tree_list (cl, NULL_TREE);
3586   else
3587     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3588
3589   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3590     return to_return;
3591
3592   /* We're dealing with a qualified name. Try to resolve thing until
3593      we get something that is an enclosing class. */
3594   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3595     {
3596       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3597
3598       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3599            qual = TREE_CHAIN (qual))
3600         {
3601           acc = merge_qualified_name (acc,
3602                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3603           BUILD_PTR_FROM_NAME (ptr, acc);
3604           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3605         }
3606
3607       /* A NULL qual and a decl means that the search ended
3608          successfully?!? We have to do something then. FIXME */
3609
3610       if (decl)
3611         enclosing = decl;
3612       else
3613         qual = EXPR_WFL_QUALIFICATION (cl);
3614     }
3615   /* Otherwise, create a qual for the other part of the resolution. */
3616   else
3617     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3618
3619   return find_as_inner_class_do (qual, enclosing);
3620 }
3621
3622 /* We go inside the list of sub classes and try to find a way
3623    through. */
3624
3625 static tree
3626 find_as_inner_class_do (tree qual, tree enclosing)
3627 {
3628   if (!qual)
3629     return NULL_TREE;
3630
3631   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3632     {
3633       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3634       tree next_enclosing = NULL_TREE;
3635       tree inner_list;
3636
3637       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3638            inner_list; inner_list = TREE_CHAIN (inner_list))
3639         {
3640           if (TREE_VALUE (inner_list) == name_to_match)
3641             {
3642               next_enclosing = TREE_PURPOSE (inner_list);
3643               break;
3644             }
3645         }
3646       enclosing = next_enclosing;
3647     }
3648
3649   return (!qual && enclosing ? enclosing : NULL_TREE);
3650 }
3651
3652 /* Reach all inner classes and tie their unqualified name to a
3653    DECL. */
3654
3655 static void
3656 set_nested_class_simple_name_value (tree outer, int set)
3657 {
3658   tree l;
3659
3660   for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
3661     IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
3662                                                 TREE_PURPOSE (l) : NULL_TREE);
3663 }
3664
3665 static void
3666 link_nested_class_to_enclosing (void)
3667 {
3668   if (GET_ENCLOSING_CPC ())
3669     {
3670       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3671       DECL_INNER_CLASS_LIST (enclosing) =
3672         tree_cons (GET_CPC (), GET_CPC_UN (),
3673                    DECL_INNER_CLASS_LIST (enclosing));
3674     }
3675 }
3676
3677 static tree
3678 maybe_make_nested_class_name (tree name)
3679 {
3680   tree id = NULL_TREE;
3681
3682   if (CPC_INNER_P ())
3683     {
3684       /* If we're in a function, we must append a number to create the
3685          nested class name.  However, we don't do this if the class we
3686          are constructing is anonymous, because in that case we'll
3687          already have a number as the class name.  */
3688       if (! make_nested_class_name (GET_CPC_LIST ())
3689           && current_function_decl != NULL_TREE
3690           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3691         {
3692           char buf[10];
3693           sprintf (buf, "%d", anonymous_class_counter);
3694           ++anonymous_class_counter;
3695           obstack_grow (&temporary_obstack, buf, strlen (buf));
3696           obstack_1grow (&temporary_obstack, '$');
3697         }
3698       obstack_grow0 (&temporary_obstack,
3699                      IDENTIFIER_POINTER (name),
3700                      IDENTIFIER_LENGTH (name));
3701       id = get_identifier (obstack_finish (&temporary_obstack));
3702       if (ctxp->package)
3703         QUALIFIED_P (id) = 1;
3704     }
3705   return id;
3706 }
3707
3708 /* If DECL is NULL, create and push a new DECL, record the current
3709    line CL and do other maintenance things.  */
3710
3711 static tree
3712 maybe_create_class_interface_decl (tree decl, tree raw_name,
3713                                    tree qualified_name, tree cl)
3714 {
3715   if (!decl)
3716     decl = push_class (make_class (), qualified_name);
3717
3718   /* Take care of the file and line business */
3719   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3720   /* If we're emiting xrefs, store the line/col number information */
3721   if (flag_emit_xref)
3722     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3723   else
3724     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3725   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3726   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3727   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3728     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3729
3730   PUSH_CPC (decl, raw_name);
3731   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3732
3733   /* Link the declaration to the already seen ones */
3734   TREE_CHAIN (decl) = ctxp->class_list;
3735   ctxp->class_list = decl;
3736
3737   /* Create a new nodes in the global lists */
3738   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3739   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3740
3741   /* Install a new dependency list element */
3742   create_jdep_list (ctxp);
3743
3744   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3745                           IDENTIFIER_POINTER (qualified_name)));
3746   return decl;
3747 }
3748
3749 static void
3750 add_superinterfaces (tree decl, tree interface_list)
3751 {
3752   tree node;
3753   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3754      takes care of ensuring that:
3755        - This is an accessible interface type,
3756        - Circularity detection.
3757    parser_add_interface is then called. If present but not defined,
3758    the check operation is delayed until the super interface gets
3759    defined.  */
3760   for (node = interface_list; node; node = TREE_CHAIN (node))
3761     {
3762       tree current = TREE_PURPOSE (node);
3763       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3764       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3765         {
3766           if (!parser_check_super_interface (idecl, decl, current))
3767             parser_add_interface (decl, idecl, current);
3768         }
3769       else
3770         register_incomplete_type (JDEP_INTERFACE,
3771                                   current, decl, NULL_TREE);
3772     }
3773 }
3774
3775 /* Create an interface in pass1 and return its decl. Return the
3776    interface's decl in pass 2.  */
3777
3778 static tree
3779 create_interface (int flags, tree id, tree super)
3780 {
3781   tree raw_name = EXPR_WFL_NODE (id);
3782   tree q_name = parser_qualified_classname (raw_name);
3783   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3784
3785   /* Certain syntax errors are making SUPER be like ID. Avoid this
3786      case. */
3787   if (ctxp->class_err && id == super)
3788     super = NULL;
3789
3790   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3791
3792   /* Basic checks: scope, redefinition, modifiers */
3793   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3794     {
3795       PUSH_ERROR ();
3796       return NULL_TREE;
3797     }
3798
3799   /* Suspend the current parsing context if we're parsing an inner
3800      interface */
3801   if (CPC_INNER_P ())
3802     {
3803       java_parser_context_suspend ();
3804       /* Interface members are public. */
3805       if (CLASS_INTERFACE (GET_CPC ()))
3806         flags |= ACC_PUBLIC;
3807     }
3808
3809   /* Push a new context for (static) initialized upon declaration fields */
3810   java_parser_context_push_initialized_field ();
3811
3812   /* Interface modifiers check
3813        - public/abstract allowed (already done at that point)
3814        - abstract is obsolete (comes first, it's a warning, or should be)
3815        - Can't use twice the same (checked in the modifier rule) */
3816   if ((flags & ACC_ABSTRACT) && flag_redundant)
3817     parse_warning_context
3818       (MODIFIER_WFL (ABSTRACT_TK),
3819        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3820
3821   /* Create a new decl if DECL is NULL, otherwise fix it */
3822   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3823
3824   /* Set super info and mark the class a complete */
3825   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3826                   object_type_node, ctxp->interface_number);
3827   ctxp->interface_number = 0;
3828   CLASS_COMPLETE_P (decl) = 1;
3829   add_superinterfaces (decl, super);
3830
3831   /* Eventually sets the @deprecated tag flag */
3832   CHECK_DEPRECATED (decl);
3833
3834   return decl;
3835 }
3836
3837 /* Patch anonymous class CLASS, by either extending or implementing
3838    DEP.  */
3839
3840 static void
3841 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
3842 {
3843   tree class = TREE_TYPE (class_decl);
3844   tree type =  TREE_TYPE (type_decl);
3845   tree binfo = TYPE_BINFO (class);
3846
3847   /* If it's an interface, implement it */
3848   if (CLASS_INTERFACE (type_decl))
3849     {
3850       tree s_binfo;
3851       int length;
3852
3853       if (parser_check_super_interface (type_decl, class_decl, wfl))
3854         return;
3855
3856       s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3857       length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3858       TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3859       TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3860       /* And add the interface */
3861       parser_add_interface (class_decl, type_decl, wfl);
3862     }
3863   /* Otherwise, it's a type we want to extend */
3864   else
3865     {
3866       if (parser_check_super (type_decl, class_decl, wfl))
3867         return;
3868       BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3869     }
3870 }
3871
3872 static tree
3873 create_anonymous_class (int location, tree type_name)
3874 {
3875   char buffer [80];
3876   tree super = NULL_TREE, itf = NULL_TREE;
3877   tree id, type_decl, class;
3878
3879   /* The unqualified name of the anonymous class. It's just a number. */
3880   sprintf (buffer, "%d", anonymous_class_counter++);
3881   id = build_wfl_node (get_identifier (buffer));
3882   EXPR_WFL_LINECOL (id) = location;
3883
3884   /* We know about the type to extend/implement. We go ahead */
3885   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3886     {
3887       /* Create a class which either implements on extends the designated
3888          class. The class bears an innacessible name. */
3889       if (CLASS_INTERFACE (type_decl))
3890         {
3891           /* It's OK to modify it here. It's been already used and
3892              shouldn't be reused */
3893           ctxp->interface_number = 1;
3894           /* Interfaces should presented as a list of WFLs */
3895           itf = build_tree_list (type_name, NULL_TREE);
3896         }
3897       else
3898         super = type_name;
3899     }
3900
3901   class = create_class (ACC_FINAL, id, super, itf);
3902
3903   /* We didn't know anything about the stuff. We register a dependence. */
3904   if (!type_decl)
3905     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3906
3907   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3908   return class;
3909 }
3910
3911 /* Create a class in pass1 and return its decl. Return class
3912    interface's decl in pass 2.  */
3913
3914 static tree
3915 create_class (int flags, tree id, tree super, tree interfaces)
3916 {
3917   tree raw_name = EXPR_WFL_NODE (id);
3918   tree class_id, decl;
3919   tree super_decl_type;
3920
3921   /* Certain syntax errors are making SUPER be like ID. Avoid this
3922      case. */
3923   if (ctxp->class_err && id == super)
3924     super = NULL;
3925
3926   class_id = parser_qualified_classname (raw_name);
3927   decl = IDENTIFIER_CLASS_VALUE (class_id);
3928   EXPR_WFL_NODE (id) = class_id;
3929
3930   /* Basic check: scope, redefinition, modifiers */
3931   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3932     {
3933       PUSH_ERROR ();
3934       return NULL_TREE;
3935     }
3936
3937   /* Suspend the current parsing context if we're parsing an inner
3938      class or an anonymous class. */
3939   if (CPC_INNER_P ())
3940     {
3941       java_parser_context_suspend ();
3942       /* Interface members are public. */
3943       if (CLASS_INTERFACE (GET_CPC ()))
3944         flags |= ACC_PUBLIC;
3945     }
3946
3947   /* Push a new context for (static) initialized upon declaration fields */
3948   java_parser_context_push_initialized_field ();
3949
3950   /* Class modifier check:
3951        - Allowed modifier (already done at that point)
3952        - abstract AND final forbidden
3953        - Public classes defined in the correct file */
3954   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
3955     parse_error_context
3956       (id, "Class `%s' can't be declared both abstract and final",
3957        IDENTIFIER_POINTER (raw_name));
3958
3959   /* Create a new decl if DECL is NULL, otherwise fix it */
3960   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
3961
3962   /* If SUPER exists, use it, otherwise use Object */
3963   if (super)
3964     {
3965       /* Can't extend java.lang.Object */
3966       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
3967         {
3968           parse_error_context (id, "Can't extend `java.lang.Object'");
3969           return NULL_TREE;
3970         }
3971
3972       super_decl_type =
3973         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
3974     }
3975   else if (TREE_TYPE (decl) != object_type_node)
3976     super_decl_type = object_type_node;
3977   /* We're defining java.lang.Object */
3978   else
3979     super_decl_type = NULL_TREE;
3980
3981   /* A class nested in an interface is implicitly static. */
3982   if (INNER_CLASS_DECL_P (decl)
3983       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
3984     {
3985       flags |= ACC_STATIC;
3986     }
3987
3988   /* Set super info and mark the class as complete. */
3989   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
3990                   ctxp->interface_number);
3991   ctxp->interface_number = 0;
3992   CLASS_COMPLETE_P (decl) = 1;
3993   add_superinterfaces (decl, interfaces);
3994
3995   /* Add the private this$<n> field, Replicate final locals still in
3996      scope as private final fields mangled like val$<local_name>.
3997      This doesn't not occur for top level (static) inner classes. */
3998   if (PURE_INNER_CLASS_DECL_P (decl))
3999     add_inner_class_fields (decl, current_function_decl);
4000
4001   /* If doing xref, store the location at which the inherited class
4002      (if any) was seen. */
4003   if (flag_emit_xref && super)
4004     DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4005
4006   /* Eventually sets the @deprecated tag flag */
4007   CHECK_DEPRECATED (decl);
4008
4009   /* Reset the anonymous class counter when declaring non inner classes */
4010   if (!INNER_CLASS_DECL_P (decl))
4011     anonymous_class_counter = 1;
4012
4013   return decl;
4014 }
4015
4016 /* End a class declaration: register the statements used to create
4017    finit$ and <clinit>, pop the current class and resume the prior
4018    parser context if necessary.  */
4019
4020 static void
4021 end_class_declaration (int resume)
4022 {
4023   /* If an error occurred, context weren't pushed and won't need to be
4024      popped by a resume. */
4025   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4026
4027   if (GET_CPC () != error_mark_node)
4028     dump_java_tree (TDI_class, GET_CPC ());
4029
4030   java_parser_context_pop_initialized_field ();
4031   POP_CPC ();
4032   if (resume && no_error_occurred)
4033     java_parser_context_resume ();
4034
4035   /* We're ending a class declaration, this is a good time to reset
4036      the interface cout. Note that might have been already done in
4037      create_interface, but if at that time an inner class was being
4038      dealt with, the interface count was reset in a context created
4039      for the sake of handling inner classes declaration. */
4040   ctxp->interface_number = 0;
4041 }
4042
4043 static void
4044 add_inner_class_fields (tree class_decl, tree fct_decl)
4045 {
4046   tree block, marker, f;
4047
4048   f = add_field (TREE_TYPE (class_decl),
4049                  build_current_thisn (TREE_TYPE (class_decl)),
4050                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4051                  ACC_PRIVATE);
4052   FIELD_THISN (f) = 1;
4053
4054   if (!fct_decl)
4055     return;
4056
4057   for (block = GET_CURRENT_BLOCK (fct_decl);
4058        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4059     {
4060       tree decl;
4061       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4062         {
4063           tree name, pname;
4064           tree wfl, init, list;
4065
4066           /* Avoid non final arguments. */
4067           if (!LOCAL_FINAL_P (decl))
4068             continue;
4069
4070           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4071           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4072           wfl = build_wfl_node (name);
4073           init = build_wfl_node (pname);
4074           /* Build an initialization for the field: it will be
4075              initialized by a parameter added to finit$, bearing a
4076              mangled name of the field itself (param$<n>.) The
4077              parameter is provided to finit$ by the constructor
4078              invoking it (hence the constructor will also feature a
4079              hidden parameter, set to the value of the outer context
4080              local at the time the inner class is created.)
4081
4082              Note: we take into account all possible locals that can
4083              be accessed by the inner class. It's actually not trivial
4084              to minimize these aliases down to the ones really
4085              used. One way to do that would be to expand all regular
4086              methods first, then finit$ to get a picture of what's
4087              used.  It works with the exception that we would have to
4088              go back on all constructor invoked in regular methods to
4089              have their invokation reworked (to include the right amount
4090              of alias initializer parameters.)
4091
4092              The only real way around, I think, is a first pass to
4093              identify locals really used in the inner class. We leave
4094              the flag FIELD_LOCAL_ALIAS_USED around for that future
4095              use.
4096
4097              On the other hand, it only affect local inner classes,
4098              whose constructors (and finit$ call) will be featuring
4099              unecessary arguments. It's easy for a developper to keep
4100              this number of parameter down by using the `final'
4101              keyword only when necessary. For the time being, we can
4102              issue a warning on unecessary finals. FIXME */
4103           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4104                                    wfl, init);
4105
4106           /* Register the field. The TREE_LIST holding the part
4107              initialized/initializer will be marked ARG_FINAL_P so
4108              that the created field can be marked
4109              FIELD_LOCAL_ALIAS. */
4110           list = build_tree_list (wfl, init);
4111           ARG_FINAL_P (list) = 1;
4112           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4113         }
4114     }
4115
4116   if (!CPC_INITIALIZER_STMT (ctxp))
4117     return;
4118
4119   /* If we ever registered an alias field, insert and marker to
4120      remeber where the list ends. The second part of the list (the one
4121      featuring initialized fields) so it can be later reversed to
4122      enforce 8.5. The marker will be removed during that operation. */
4123   marker = build_tree_list (NULL_TREE, NULL_TREE);
4124   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4125   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4126 }
4127
4128 /* Can't use lookup_field () since we don't want to load the class and
4129    can't set the CLASS_LOADED_P flag */
4130
4131 static tree
4132 find_field (tree class, tree name)
4133 {
4134   tree decl;
4135   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4136     {
4137       if (DECL_NAME (decl) == name)
4138         return decl;
4139     }
4140   return NULL_TREE;
4141 }
4142
4143 /* Wrap around lookup_field that doesn't potentially upset the value
4144    of CLASS */
4145
4146 static tree
4147 lookup_field_wrapper (tree class, tree name)
4148 {
4149   tree type = class;
4150   tree decl = NULL_TREE;
4151   java_parser_context_save_global ();
4152
4153   /* Last chance: if we're within the context of an inner class, we
4154      might be trying to access a local variable defined in an outer
4155      context. We try to look for it now. */
4156   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4157     {
4158       tree new_name;
4159       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4160       decl = lookup_field (&type, new_name);
4161       if (decl && decl != error_mark_node)
4162         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4163     }
4164   if (!decl || decl == error_mark_node)
4165     {
4166       type = class;
4167       decl = lookup_field (&type, name);
4168     }
4169
4170   /* If the field still hasn't been found, try the next enclosing context. */
4171   if (!decl && INNER_CLASS_TYPE_P (class))
4172     {
4173       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4174       decl = lookup_field_wrapper (outer_type, name);
4175     }
4176
4177   java_parser_context_restore_global ();
4178   return decl == error_mark_node ? NULL : decl;
4179 }
4180
4181 /* Find duplicate field within the same class declarations and report
4182    the error. Returns 1 if a duplicated field was found, 0
4183    otherwise.  */
4184
4185 static int
4186 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4187 {
4188   /* This might be modified to work with method decl as well */
4189   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4190   if (decl)
4191     {
4192       char *t1 = xstrdup (purify_type_name
4193                          ((TREE_CODE (new_type) == POINTER_TYPE
4194                            && TREE_TYPE (new_type) == NULL_TREE) ?
4195                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4196                           lang_printable_name (new_type, 1)));
4197       /* The type may not have been completed by the time we report
4198          the error */
4199       char *t2 = xstrdup (purify_type_name
4200                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4201                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4202                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4203                           lang_printable_name (TREE_TYPE (decl), 1)));
4204       parse_error_context
4205         (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4206          t1, IDENTIFIER_POINTER (new_field_name),
4207          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4208          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4209       free (t1);
4210       free (t2);
4211       return 1;
4212     }
4213   return 0;
4214 }
4215
4216 /* Field registration routine. If TYPE doesn't exist, field
4217    declarations are linked to the undefined TYPE dependency list, to
4218    be later resolved in java_complete_class () */
4219
4220 static void
4221 register_fields (int flags, tree type, tree variable_list)
4222 {
4223   tree current, saved_type;
4224   tree class_type = NULL_TREE;
4225   int saved_lineno = input_line;
4226   int must_chain = 0;
4227   tree wfl = NULL_TREE;
4228
4229   if (GET_CPC ())
4230     class_type = TREE_TYPE (GET_CPC ());
4231
4232   if (!class_type || class_type == error_mark_node)
4233     return;
4234
4235   /* If we're adding fields to interfaces, those fields are public,
4236      static, final */
4237   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4238     {
4239       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4240                                  flags, ACC_PUBLIC, "interface field(s)");
4241       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4242                                  flags, ACC_STATIC, "interface field(s)");
4243       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4244                                  flags, ACC_FINAL, "interface field(s)");
4245       check_modifiers ("Illegal interface member modifier `%s'", flags,
4246                        INTERFACE_FIELD_MODIFIERS);
4247       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4248     }
4249
4250   /* Obtain a suitable type for resolution, if necessary */
4251   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4252
4253   /* If TYPE is fully resolved and we don't have a reference, make one */
4254   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4255
4256   for (current = variable_list, saved_type = type; current;
4257        current = TREE_CHAIN (current), type = saved_type)
4258     {
4259       tree real_type;
4260       tree field_decl;
4261       tree cl = TREE_PURPOSE (current);
4262       tree init = TREE_VALUE (current);
4263       tree current_name = EXPR_WFL_NODE (cl);
4264
4265       /* Can't declare non-final static fields in inner classes */
4266       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4267           && !(flags & ACC_FINAL))
4268         parse_error_context
4269           (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4270            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4271            lang_printable_name (class_type, 0));
4272
4273       /* Process NAME, as it may specify extra dimension(s) for it */
4274       type = build_array_from_name (type, wfl, current_name, &current_name);
4275
4276       /* Type adjustment. We may have just readjusted TYPE because
4277          the variable specified more dimensions. Make sure we have
4278          a reference if we can and don't have one already. Also
4279          change the name if we have an init. */
4280       if (type != saved_type)
4281         {
4282           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4283           if (init)
4284             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4285         }
4286
4287       real_type = GET_REAL_TYPE (type);
4288       /* Check for redeclarations */
4289       if (duplicate_declaration_error_p (current_name, real_type, cl))
4290         continue;
4291
4292       /* Set lineno to the line the field was found and create a
4293          declaration for it. Eventually sets the @deprecated tag flag. */
4294       if (flag_emit_xref)
4295         input_line = EXPR_WFL_LINECOL (cl);
4296       else
4297         input_line = EXPR_WFL_LINENO (cl);
4298       field_decl = add_field (class_type, current_name, real_type, flags);
4299       CHECK_DEPRECATED_NO_RESET (field_decl);
4300
4301       /* If the field denotes a final instance variable, then we
4302          allocate a LANG_DECL_SPECIFIC part to keep track of its
4303          initialization. We also mark whether the field was
4304          initialized upon its declaration. We don't do that if the
4305          created field is an alias to a final local. */
4306       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4307         {
4308           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4309           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4310         }
4311
4312       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4313          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4314          hide parameters to this inner class finit$ and
4315          constructors. It also means that the field isn't final per
4316          say. */
4317       if (ARG_FINAL_P (current))
4318         {
4319           FIELD_LOCAL_ALIAS (field_decl) = 1;
4320           FIELD_FINAL (field_decl) = 0;
4321         }
4322
4323       /* Check if we must chain. */
4324       if (must_chain)
4325         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4326
4327       /* If we have an initialization value tied to the field */
4328       if (init)
4329         {
4330           /* The field is declared static */
4331           if (flags & ACC_STATIC)
4332             {
4333               /* We include the field and its initialization part into
4334                  a list used to generate <clinit>. After <clinit> is
4335                  walked, field initializations will be processed and
4336                  fields initialized with known constants will be taken
4337                  out of <clinit> and have their DECL_INITIAL set
4338                  appropriately. */
4339               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4340               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4341               if (TREE_OPERAND (init, 1)
4342                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4343                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4344             }
4345           /* A non-static field declared with an immediate initialization is
4346              to be initialized in <init>, if any.  This field is remembered
4347              to be processed at the time of the generation of <init>. */
4348           else
4349             {
4350               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4351               SET_CPC_INITIALIZER_STMT (ctxp, init);
4352             }
4353           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4354           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4355         }
4356     }
4357
4358   CLEAR_DEPRECATED;
4359   input_line = saved_lineno;
4360 }
4361
4362 /* Generate finit$, using the list of initialized fields to populate
4363    its body. finit$'s parameter(s) list is adjusted to include the
4364    one(s) used to initialized the field(s) caching outer context
4365    local(s).  */
4366
4367 static tree
4368 generate_finit (tree class_type)
4369 {
4370   int count = 0;
4371   tree list = TYPE_FINIT_STMT_LIST (class_type);
4372   tree mdecl, current, parms;
4373
4374   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4375                                                   class_type, NULL_TREE,
4376                                                   &count);
4377   CRAFTED_PARAM_LIST_FIXUP (parms);
4378   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4379                                     finit_identifier_node, parms);
4380   fix_method_argument_names (parms, mdecl);
4381   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4382                        mdecl, NULL_TREE);
4383   DECL_FUNCTION_NAP (mdecl) = count;
4384   start_artificial_method_body (mdecl);
4385
4386   for (current = list; current; current = TREE_CHAIN (current))
4387     java_method_add_stmt (mdecl,
4388                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4389                                                 current));
4390   end_artificial_method_body (mdecl);
4391   return mdecl;
4392 }
4393
4394 /* Generate a function to run the instance initialization code. The
4395    private method is called `instinit$'. Unless we're dealing with an
4396    anonymous class, we determine whether all ctors of CLASS_TYPE
4397    declare a checked exception in their `throws' clause in order to
4398    see whether it's necessary to encapsulate the instance initializer
4399    statements in a try/catch/rethrow sequence.  */
4400
4401 static tree
4402 generate_instinit (tree class_type)
4403 {
4404   tree current;
4405   tree compound = NULL_TREE;
4406   tree parms = tree_cons (this_identifier_node,
4407                           build_pointer_type (class_type), end_params_node);
4408   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4409                                          void_type_node,
4410                                          instinit_identifier_node, parms);
4411
4412   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4413                        mdecl, NULL_TREE);
4414
4415   /* Gather all the statements in a compound */
4416   for (current = TYPE_II_STMT_LIST (class_type);
4417        current; current = TREE_CHAIN (current))
4418     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4419
4420   /* We need to encapsulate COMPOUND by a try/catch statement to
4421      rethrow exceptions that might occur in the instance initializer.
4422      We do that only if all ctors of CLASS_TYPE are set to catch a
4423      checked exception. This doesn't apply to anonymous classes (since
4424      they don't have declared ctors.) */
4425   if (!ANONYMOUS_CLASS_P (class_type) &&
4426       ctors_unchecked_throws_clause_p (class_type))
4427     {
4428       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4429                                              build1 (THROW_EXPR, NULL_TREE,
4430                                                      build_wfl_node (wpv_id)));
4431       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4432                                                       exception_type_node);
4433     }
4434
4435   start_artificial_method_body (mdecl);
4436   java_method_add_stmt (mdecl, compound);
4437   end_artificial_method_body (mdecl);
4438
4439   return mdecl;
4440 }
4441
4442 /* FIXME */
4443 static tree
4444 build_instinit_invocation (tree class_type)
4445 {
4446   tree to_return = NULL_TREE;
4447
4448   if (TYPE_II_STMT_LIST (class_type))
4449     {
4450       tree parm = build_tree_list (NULL_TREE,
4451                                    build_wfl_node (this_identifier_node));
4452       to_return =
4453         build_method_invocation (build_wfl_node (instinit_identifier_node),
4454                                  parm);
4455     }
4456   return to_return;
4457 }
4458
4459 /* Shared accros method_declarator and method_header to remember the
4460    patch stage that was reached during the declaration of the method.
4461    A method DECL is built differently is there is no patch
4462    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4463    pending on the currently defined method.  */
4464
4465 static int patch_stage;
4466
4467 /* Check the method declaration and add the method to its current
4468    class.  If the argument list is known to contain incomplete types,
4469    the method is partially added and the registration will be resume
4470    once the method arguments resolved. If TYPE is NULL, we're dealing
4471    with a constructor.  */
4472
4473 static tree
4474 method_header (int flags, tree type, tree mdecl, tree throws)
4475 {
4476   tree type_wfl = NULL_TREE;
4477   tree meth_name = NULL_TREE;
4478   tree current, orig_arg, this_class = NULL;
4479   tree id, meth;
4480   int saved_lineno;
4481   int constructor_ok = 0, must_chain;
4482   int count;
4483
4484   if (mdecl == error_mark_node)
4485     return error_mark_node;
4486   meth = TREE_VALUE (mdecl);
4487   id = TREE_PURPOSE (mdecl);
4488
4489   check_modifiers_consistency (flags);
4490
4491   if (GET_CPC ())
4492     this_class = TREE_TYPE (GET_CPC ());
4493
4494   if (!this_class || this_class == error_mark_node)
4495     return NULL_TREE;
4496
4497   /* There are some forbidden modifiers for an abstract method and its
4498      class must be abstract as well.  */
4499   if (type && (flags & ACC_ABSTRACT))
4500     {
4501       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4502       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4503       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4504       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4505       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4506       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4507       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4508           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4509         parse_error_context
4510           (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4511            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4512            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4513     }
4514
4515   /* A native method can't be strictfp.  */
4516   if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4517     parse_error_context (id, "native method `%s' can't be strictfp",
4518                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4519   /* No such thing as a transient or volatile method.  */
4520   if ((flags & ACC_TRANSIENT))
4521     parse_error_context (id, "method `%s' can't be transient",
4522                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4523   if ((flags & ACC_VOLATILE))
4524     parse_error_context (id, "method `%s' can't be volatile",
4525                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4526
4527   /* Things to be checked when declaring a constructor */
4528   if (!type)
4529     {
4530       int ec = java_error_count;
4531       /* 8.6: Constructor declarations: we might be trying to define a
4532          method without specifying a return type. */
4533       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4534         parse_error_context
4535           (id, "Invalid method declaration, return type required");
4536       /* 8.6.3: Constructor modifiers */
4537       else
4538         {
4539           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4540           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4541           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4542           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4543           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4544           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4545         }
4546       /* If we found error here, we don't consider it's OK to tread
4547          the method definition as a constructor, for the rest of this
4548          function */
4549       if (ec == java_error_count)
4550         constructor_ok = 1;
4551     }
4552
4553   /* Method declared within the scope of an interface are implicitly
4554      abstract and public. Conflicts with other erroneously provided
4555      modifiers are checked right after. */
4556
4557   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4558     {
4559       /* If FLAGS isn't set because of a modifier, turn the
4560          corresponding modifier WFL to NULL so we issue a warning on
4561          the obsolete use of the modifier */
4562       if (!(flags & ACC_PUBLIC))
4563         MODIFIER_WFL (PUBLIC_TK) = NULL;
4564       if (!(flags & ACC_ABSTRACT))
4565         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4566       flags |= ACC_PUBLIC;
4567       flags |= ACC_ABSTRACT;
4568     }
4569
4570   /* Inner class can't declare static methods */
4571   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4572     {
4573       parse_error_context
4574         (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4575          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4576          lang_printable_name (this_class, 0));
4577     }
4578
4579   /* Modifiers context reset moved up, so abstract method declaration
4580      modifiers can be later checked.  */
4581
4582   /* Set constructor returned type to void and method name to <init>,
4583      unless we found an error identifier the constructor (in which
4584      case we retain the original name) */
4585   if (!type)
4586     {
4587       type = void_type_node;
4588       if (constructor_ok)
4589         meth_name = init_identifier_node;
4590     }
4591   else
4592     meth_name = EXPR_WFL_NODE (id);
4593
4594   /* Do the returned type resolution and registration if necessary */
4595   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4596
4597   if (meth_name)
4598     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4599   EXPR_WFL_NODE (id) = meth_name;
4600   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4601
4602   if (must_chain)
4603     {
4604       patch_stage = JDEP_METHOD_RETURN;
4605       register_incomplete_type (patch_stage, type_wfl, id, type);
4606       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4607     }
4608   else
4609     TREE_TYPE (meth) = type;
4610
4611   saved_lineno = input_line;
4612   /* When defining an abstract or interface method, the curly
4613      bracket at level 1 doesn't exist because there is no function
4614      body */
4615   input_line = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4616             EXPR_WFL_LINENO (id));
4617
4618   /* Remember the original argument list */
4619   orig_arg = TYPE_ARG_TYPES (meth);
4620
4621   if (patch_stage)              /* includes ret type and/or all args */
4622     {
4623       jdep *jdep;
4624       meth = add_method_1 (this_class, flags, meth_name, meth);
4625       /* Patch for the return type */
4626       if (patch_stage == JDEP_METHOD_RETURN)
4627         {
4628           jdep = CLASSD_LAST (ctxp->classd_list);
4629           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4630         }
4631       /* This is the stop JDEP. METH allows the function's signature
4632          to be computed. */
4633       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4634     }
4635   else
4636     meth = add_method (this_class, flags, meth_name,
4637                        build_java_signature (meth));
4638
4639   /* Remember final parameters */
4640   MARK_FINAL_PARMS (meth, orig_arg);
4641
4642   /* Fix the method argument list so we have the argument name
4643      information */
4644   fix_method_argument_names (orig_arg, meth);
4645
4646   /* Register the parameter number and re-install the current line
4647      number */
4648   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4649   input_line = saved_lineno;
4650
4651   /* Register exception specified by the `throws' keyword for
4652      resolution and set the method decl appropriate field to the list.
4653      Note: the grammar ensures that what we get here are class
4654      types. */
4655   if (throws)
4656     {
4657       throws = nreverse (throws);
4658       for (current = throws; current; current = TREE_CHAIN (current))
4659         {
4660           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4661                                     NULL_TREE, NULL_TREE);
4662           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4663             &TREE_VALUE (current);
4664         }
4665       DECL_FUNCTION_THROWS (meth) = throws;
4666     }
4667
4668   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4669     DECL_FUNCTION_WFL (meth) = id;
4670
4671   /* Set the flag if we correctly processed a constructor */
4672   if (constructor_ok)
4673     {
4674       DECL_CONSTRUCTOR_P (meth) = 1;
4675       /* Compute and store the number of artificial parameters declared
4676          for this constructor */
4677       for (count = 0, current = TYPE_FIELDS (this_class); current;
4678            current = TREE_CHAIN (current))
4679         if (FIELD_LOCAL_ALIAS (current))
4680           count++;
4681       DECL_FUNCTION_NAP (meth) = count;
4682     }
4683
4684   /* Eventually set the @deprecated tag flag */
4685   CHECK_DEPRECATED (meth);
4686
4687   /* If doing xref, store column and line number information instead
4688      of the line number only. */
4689   if (flag_emit_xref)
4690     DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4691
4692   return meth;
4693 }
4694
4695 static void
4696 fix_method_argument_names (tree orig_arg, tree meth)
4697 {
4698   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4699   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4700     {
4701       TREE_PURPOSE (arg) = this_identifier_node;
4702       arg = TREE_CHAIN (arg);
4703     }
4704   while (orig_arg != end_params_node)
4705     {
4706       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4707       orig_arg = TREE_CHAIN (orig_arg);
4708       arg = TREE_CHAIN (arg);
4709     }
4710 }
4711
4712 /* Complete the method declaration with METHOD_BODY.  */
4713
4714 static void
4715 finish_method_declaration (tree method_body)
4716 {
4717   int flags;
4718
4719   if (!current_function_decl)
4720     return;
4721
4722   flags = get_access_flags_from_decl (current_function_decl);
4723
4724   /* 8.4.5 Method Body */
4725   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4726     {
4727       tree name = DECL_NAME (current_function_decl);
4728       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4729                            "%s method `%s' can't have a body defined",
4730                            (METHOD_NATIVE (current_function_decl) ?
4731                             "Native" : "Abstract"),
4732                            IDENTIFIER_POINTER (name));
4733       method_body = NULL_TREE;
4734     }
4735   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4736     {
4737       tree name = DECL_NAME (current_function_decl);
4738       parse_error_context
4739         (DECL_FUNCTION_WFL (current_function_decl),
4740          "Non native and non abstract method `%s' must have a body defined",
4741          IDENTIFIER_POINTER (name));
4742       method_body = NULL_TREE;
4743     }
4744
4745   if (flag_emit_class_files && method_body
4746       && TREE_CODE (method_body) == NOP_EXPR
4747       && TREE_TYPE (current_function_decl)
4748       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4749     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4750
4751   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4752   maybe_absorb_scoping_blocks ();
4753   /* Exit function's body */
4754   exit_block ();
4755   /* Merge last line of the function with first line, directly in the
4756      function decl. It will be used to emit correct debug info. */
4757   if (!flag_emit_xref)
4758     DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4759
4760   /* Since function's argument's list are shared, reset the
4761      ARG_FINAL_P parameter that might have been set on some of this
4762      function parameters. */
4763   UNMARK_FINAL_PARMS (current_function_decl);
4764
4765   /* So we don't have an irrelevant function declaration context for
4766      the next static block we'll see. */
4767   current_function_decl = NULL_TREE;
4768 }
4769
4770 /* Build a an error message for constructor circularity errors.  */
4771
4772 static char *
4773 constructor_circularity_msg (tree from, tree to)
4774 {
4775   static char string [4096];
4776   char *t = xstrdup (lang_printable_name (from, 0));
4777   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4778   free (t);
4779   return string;
4780 }
4781
4782 /* Verify a circular call to METH. Return 1 if an error is found, 0
4783    otherwise.  */
4784
4785 static GTY(()) tree vcc_list;
4786 static int
4787 verify_constructor_circularity (tree meth, tree current)
4788 {
4789   tree c;
4790
4791   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4792     {
4793       if (TREE_VALUE (c) == meth)
4794         {
4795           char *t;
4796           if (vcc_list)
4797             {
4798               tree liste;
4799               vcc_list = nreverse (vcc_list);
4800               for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4801                 {
4802                   parse_error_context
4803                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4804                      constructor_circularity_msg
4805                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4806                   java_error_count--;
4807                 }
4808             }
4809           t = xstrdup (lang_printable_name (meth, 0));
4810           parse_error_context (TREE_PURPOSE (c),
4811                                "%s: recursive invocation of constructor `%s'",
4812                                constructor_circularity_msg (current, meth), t);
4813           free (t);
4814           vcc_list = NULL_TREE;
4815           return 1;
4816         }
4817     }
4818   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4819     {
4820       vcc_list = tree_cons (c, current, vcc_list);
4821       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4822         return 1;
4823       vcc_list = TREE_CHAIN (vcc_list);
4824     }
4825   return 0;
4826 }
4827
4828 /* Check modifiers that can be declared but exclusively */
4829
4830 static void
4831 check_modifiers_consistency (int flags)
4832 {
4833   int acc_count = 0;
4834   tree cl = NULL_TREE;
4835
4836   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4837   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4838   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4839   if (acc_count > 1)
4840     parse_error_context
4841       (cl, "Inconsistent member declaration.  At most one of `public', `private', or `protected' may be specified");
4842
4843   acc_count = 0;
4844   cl = NULL_TREE;
4845   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4846   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4847   if (acc_count > 1)
4848     parse_error_context (cl,
4849                          "Inconsistent member declaration.  At most one of `final' or `volatile' may be specified");
4850 }
4851
4852 /* Check the methode header METH for abstract specifics features */
4853
4854 static void
4855 check_abstract_method_header (tree meth)
4856 {
4857   int flags = get_access_flags_from_decl (meth);
4858
4859   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4860                               ACC_ABSTRACT, "abstract method",
4861                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4862   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4863                               ACC_PUBLIC, "abstract method",
4864                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4865
4866   check_modifiers ("Illegal modifier `%s' for interface method",
4867                   flags, INTERFACE_METHOD_MODIFIERS);
4868 }
4869
4870 /* Create a FUNCTION_TYPE node and start augmenting it with the
4871    declared function arguments. Arguments type that can't be resolved
4872    are left as they are, but the returned node is marked as containing
4873    incomplete types.  */
4874
4875 static tree
4876 method_declarator (tree id, tree list)
4877 {
4878   tree arg_types = NULL_TREE, current, node;
4879   tree meth = make_node (FUNCTION_TYPE);
4880   jdep *jdep;
4881
4882   patch_stage = JDEP_NO_PATCH;
4883
4884   if (GET_CPC () == error_mark_node)
4885     return error_mark_node;
4886
4887   /* If we're dealing with an inner class constructor, we hide the
4888      this$<n> decl in the name field of its parameter declaration.  We
4889      also might have to hide the outer context local alias
4890      initializers. Not done when the class is a toplevel class. */
4891   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4892       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4893     {
4894       tree aliases_list, type, thisn;
4895       /* First the aliases, linked to the regular parameters */
4896       aliases_list =
4897         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4898                                                 TREE_TYPE (GET_CPC ()),
4899                                                 NULL_TREE, NULL);
4900       list = chainon (nreverse (aliases_list), list);
4901
4902       /* Then this$<n> */
4903       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4904       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4905       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4906                         list);
4907     }
4908
4909   for (current = list; current; current = TREE_CHAIN (current))
4910     {
4911       int must_chain = 0;
4912       tree wfl_name = TREE_PURPOSE (current);
4913       tree type = TREE_VALUE (current);
4914       tree name = EXPR_WFL_NODE (wfl_name);
4915       tree already, arg_node;
4916       tree type_wfl = NULL_TREE;
4917       tree real_type;
4918
4919       /* Obtain a suitable type for resolution, if necessary */
4920       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4921
4922       /* Process NAME, as it may specify extra dimension(s) for it */
4923       type = build_array_from_name (type, type_wfl, name, &name);
4924       EXPR_WFL_NODE (wfl_name) = name;
4925
4926       real_type = GET_REAL_TYPE (type);
4927       if (TREE_CODE (real_type) == RECORD_TYPE)
4928         {
4929           real_type = promote_type (real_type);
4930           if (TREE_CODE (type) == TREE_LIST)
4931             TREE_PURPOSE (type) = real_type;
4932         }
4933
4934       /* Check redefinition */
4935       for (already = arg_types; already; already = TREE_CHAIN (already))
4936         if (TREE_PURPOSE (already) == name)
4937           {
4938             parse_error_context
4939               (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4940                IDENTIFIER_POINTER (name),
4941                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4942             break;
4943           }
4944
4945       /* If we've an incomplete argument type, we know there is a location
4946          to patch when the type get resolved, later.  */
4947       jdep = NULL;
4948       if (must_chain)
4949         {
4950           patch_stage = JDEP_METHOD;
4951           type = register_incomplete_type (patch_stage,
4952                                            type_wfl, wfl_name, type);
4953           jdep = CLASSD_LAST (ctxp->classd_list);
4954           JDEP_MISC (jdep) = id;
4955         }
4956
4957       /* The argument node: a name and a (possibly) incomplete type.  */
4958       arg_node = build_tree_list (name, real_type);
4959       /* Remeber arguments declared final. */
4960       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
4961
4962       if (jdep)
4963         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
4964       TREE_CHAIN (arg_node) = arg_types;
4965       arg_types = arg_node;
4966     }
4967   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
4968   node = build_tree_list (id, meth);
4969   return node;
4970 }
4971
4972 static int
4973 unresolved_type_p (tree wfl, tree *returned)
4974
4975 {
4976   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
4977     {
4978       if (returned)
4979         {
4980           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
4981           if (decl && current_class && (decl == TYPE_NAME (current_class)))
4982             *returned = TREE_TYPE (decl);
4983           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
4984             *returned = TREE_TYPE (GET_CPC ());
4985           else
4986             *returned = NULL_TREE;
4987         }
4988       return 1;
4989     }
4990   if (returned)
4991     *returned = wfl;
4992   return 0;
4993 }
4994
4995 /* From NAME, build a qualified identifier node using the
4996    qualification from the current package definition. */
4997
4998 static tree
4999 parser_qualified_classname (tree name)
5000 {
5001   tree nested_class_name;
5002
5003   if ((nested_class_name = maybe_make_nested_class_name (name)))
5004     return nested_class_name;
5005
5006   if (ctxp->package)
5007     return merge_qualified_name (ctxp->package, name);
5008   else
5009     return name;
5010 }
5011
5012 /* Called once the type a interface extends is resolved. Returns 0 if
5013    everything is OK.  */
5014
5015 static int
5016 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5017 {
5018   tree super_type = TREE_TYPE (super_decl);
5019
5020   /* Has to be an interface */
5021   if (!CLASS_INTERFACE (super_decl))
5022     {
5023       parse_error_context
5024         (this_wfl, "%s `%s' can't implement/extend %s `%s'",
5025          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5026           "Interface" : "Class"),
5027          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5028          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5029          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5030       return 1;
5031     }
5032
5033   /* Check top-level interface access. Inner classes are subject to member
5034      access rules (6.6.1). */
5035   if (! INNER_CLASS_P (super_type)
5036       && check_pkg_class_access (DECL_NAME (super_decl),
5037                                  lookup_cl (this_decl), true))
5038     return 1;
5039
5040   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5041                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5042                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5043   return 0;
5044 }
5045
5046 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5047    0 if everthing is OK.  */
5048
5049 static int
5050 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5051 {
5052   tree super_type = TREE_TYPE (super_decl);
5053
5054   /* SUPER should be a CLASS (neither an array nor an interface) */
5055   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5056     {
5057       parse_error_context
5058         (wfl, "Class `%s' can't subclass %s `%s'",
5059          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5060          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5061          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5062       return 1;
5063     }
5064
5065   if (CLASS_FINAL (TYPE_NAME (super_type)))
5066     {
5067       parse_error_context (wfl, "Can't subclass final classes: %s",
5068                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5069       return 1;
5070     }
5071
5072   /* Check top-level class scope. Inner classes are subject to member access
5073      rules (6.6.1). */
5074   if (! INNER_CLASS_P (super_type)
5075       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true)))
5076     return 1;
5077
5078   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5079                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5080                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5081   return 0;
5082 }
5083
5084 /* Create a new dependency list and link it (in a LIFO manner) to the
5085    CTXP list of type dependency list.  */
5086
5087 static void
5088 create_jdep_list (struct parser_ctxt *ctxp)
5089 {
5090   jdeplist *new = xmalloc (sizeof (jdeplist));
5091   new->first = new->last = NULL;
5092   new->next = ctxp->classd_list;
5093   ctxp->classd_list = new;
5094 }
5095
5096 static jdeplist *
5097 reverse_jdep_list (struct parser_ctxt *ctxp)
5098 {
5099   register jdeplist *prev = NULL, *current, *next;
5100   for (current = ctxp->classd_list; current; current = next)
5101     {
5102       next = current->next;
5103       current->next = prev;
5104       prev = current;
5105     }
5106   return prev;
5107 }
5108
5109 /* Create a fake pointer based on the ID stored in
5110    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5111    registered again. */
5112
5113 static tree
5114 obtain_incomplete_type (tree type_name)
5115 {
5116   tree ptr = NULL_TREE, name;
5117
5118   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5119     name = EXPR_WFL_NODE (type_name);
5120   else if (INCOMPLETE_TYPE_P (type_name))
5121     name = TYPE_NAME (type_name);
5122   else
5123     abort ();
5124
5125   /* Workaround from build_pointer_type for incomplete types.  */
5126   BUILD_PTR_FROM_NAME (ptr, name);
5127   TYPE_MODE (ptr) = ptr_mode;
5128   layout_type (ptr);
5129
5130   return ptr;
5131 }
5132
5133 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5134    non NULL instead of computing a new fake type based on WFL. The new
5135    dependency is inserted in the current type dependency list, in FIFO
5136    manner.  */
5137
5138 static tree
5139 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5140 {
5141   jdep *new = xmalloc (sizeof (jdep));
5142
5143   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5144     ptr = obtain_incomplete_type (wfl);
5145
5146   JDEP_KIND (new) = kind;
5147   JDEP_DECL (new) = decl;
5148   JDEP_TO_RESOLVE (new) = ptr;
5149   JDEP_WFL (new) = wfl;
5150   JDEP_CHAIN (new) = NULL;
5151   JDEP_MISC (new) = NULL_TREE;
5152   /* For some dependencies, set the enclosing class of the current
5153      class to be the enclosing context */
5154   if ((kind == JDEP_INTERFACE  || kind == JDEP_ANONYMOUS)
5155       && GET_ENCLOSING_CPC ())
5156     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5157   else if (kind == JDEP_SUPER)
5158     JDEP_ENCLOSING (new) = (GET_ENCLOSING_CPC () ?
5159                             TREE_VALUE (GET_ENCLOSING_CPC ()) : NULL_TREE);
5160   else
5161     JDEP_ENCLOSING (new) = GET_CPC ();
5162   JDEP_GET_PATCH (new) = (tree *)NULL;
5163
5164   JDEP_INSERT (ctxp->classd_list, new);
5165
5166   return ptr;
5167 }
5168
5169 /* This checks for circular references with innerclasses. We start
5170    from SOURCE and should never reach TARGET. Extended/implemented
5171    types in SOURCE have their enclosing context checked not to reach
5172    TARGET. When the last enclosing context of SOURCE is reached, its
5173    extended/implemented types are also checked not to reach TARGET.
5174    In case of error, WFL of the offending type is returned; NULL_TREE
5175    otherwise.  */
5176
5177 static tree
5178 check_inner_circular_reference (tree source, tree target)
5179 {
5180   tree basetype_vec = TYPE_BINFO_BASETYPES (source);
5181   tree ctx, cl;
5182   int i;
5183
5184   if (!basetype_vec)
5185     return NULL_TREE;
5186
5187   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5188     {
5189       tree su;
5190
5191       /* We can end up with a NULL_TREE or an incomplete type here if
5192          we encountered previous type resolution errors. It's safe to
5193          simply ignore these cases.  */
5194       if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
5195         continue;
5196       su = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
5197       if (INCOMPLETE_TYPE_P (su))
5198         continue;
5199
5200       if (inherits_from_p (su, target))
5201         return lookup_cl (TYPE_NAME (su));
5202
5203       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5204         {
5205           /* An enclosing context shouldn't be TARGET */
5206           if (ctx == TYPE_NAME (target))
5207             return lookup_cl (TYPE_NAME (su));
5208
5209           /* When we reach the enclosing last context, start a check
5210              on it, with the same target */
5211           if (! DECL_CONTEXT (ctx) &&
5212               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5213             return cl;
5214         }
5215     }
5216   return NULL_TREE;
5217 }
5218
5219 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5220    offending type if a circularity is detected. NULL_TREE is returned
5221    otherwise. TYPE can be an interface or a class.   */
5222
5223 static tree
5224 check_circular_reference (tree type)
5225 {
5226   tree basetype_vec = TYPE_BINFO_BASETYPES (type);
5227   int i;
5228
5229   if (!basetype_vec)
5230     return NULL_TREE;
5231
5232   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5233     {
5234       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5235         return lookup_cl (TYPE_NAME (type));
5236       return NULL_TREE;
5237     }
5238
5239   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5240     {
5241       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
5242       if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
5243           && interface_of_p (type, BINFO_TYPE (vec_elt)))
5244         return lookup_cl (TYPE_NAME (BINFO_TYPE (vec_elt)));
5245     }
5246   return NULL_TREE;
5247 }
5248
5249 void
5250 java_check_circular_reference (void)
5251 {
5252   tree current;
5253   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5254     {
5255       tree type = TREE_TYPE (current);
5256       tree cl;
5257
5258       cl = check_circular_reference (type);
5259       if (! cl)
5260         cl = check_inner_circular_reference (type, type);
5261       if (cl)
5262         parse_error_context (cl, "Cyclic class inheritance%s",
5263                              (cyclic_inheritance_report ?
5264                               cyclic_inheritance_report : ""));
5265     }
5266 }
5267
5268 /* Augment the parameter list PARM with parameters crafted to
5269    initialize outer context locals aliases. Through ARTIFICIAL, a
5270    count is kept of the number of crafted parameters. MODE governs
5271    what eventually gets created: something suitable for a function
5272    creation or a function invocation, either the constructor or
5273    finit$.  */
5274
5275 static tree
5276 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5277                                         int *artificial)
5278 {
5279   tree field;
5280   tree additional_parms = NULL_TREE;
5281
5282   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5283     if (FIELD_LOCAL_ALIAS (field))
5284       {
5285         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5286         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5287         tree mangled_id;
5288
5289         switch (mode)
5290           {
5291           case AIPL_FUNCTION_DECLARATION:
5292             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5293                                                          &buffer [4]);
5294             purpose = build_wfl_node (mangled_id);
5295             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5296               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5297             else
5298               value = TREE_TYPE (field);
5299             break;
5300
5301           case AIPL_FUNCTION_CREATION:
5302             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5303                                                          &buffer [4]);
5304             value = TREE_TYPE (field);
5305             break;
5306
5307           case AIPL_FUNCTION_FINIT_INVOCATION:
5308             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5309                                                          &buffer [4]);
5310             /* Now, this is wrong. purpose should always be the NAME
5311                of something and value its matching value (decl, type,
5312                etc...) FIXME -- but there is a lot to fix. */
5313
5314             /* When invoked for this kind of operation, we already
5315                know whether a field is used or not. */
5316             purpose = TREE_TYPE (field);
5317             value = build_wfl_node (mangled_id);
5318             break;
5319
5320           case AIPL_FUNCTION_CTOR_INVOCATION:
5321             /* There are two case: the constructor invokation happends
5322                outside the local inner, in which case, locales from the outer
5323                context are directly used.
5324
5325                Otherwise, we fold to using the alias directly. */
5326             if (class_type == current_class)
5327               value = field;
5328             else
5329               {
5330                 name = get_identifier (&buffer[4]);
5331                 value = IDENTIFIER_LOCAL_VALUE (name);
5332               }
5333             break;
5334           }
5335         additional_parms = tree_cons (purpose, value, additional_parms);
5336         if (artificial)
5337           *artificial +=1;
5338       }
5339   if (additional_parms)
5340     {
5341       if (ANONYMOUS_CLASS_P (class_type)
5342           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5343         additional_parms = nreverse (additional_parms);
5344       parm = chainon (additional_parms, parm);
5345     }
5346
5347    return parm;
5348 }
5349
5350 /* Craft a constructor for CLASS_DECL -- what we should do when none
5351    where found. ARGS is non NULL when a special signature must be
5352    enforced. This is the case for anonymous classes.  */
5353
5354 static tree
5355 craft_constructor (tree class_decl, tree args)
5356 {
5357   tree class_type = TREE_TYPE (class_decl);
5358   tree parm = NULL_TREE;
5359   int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5360                ACC_PUBLIC : 0);
5361   int i = 0, artificial = 0;
5362   tree decl, ctor_name;
5363   char buffer [80];
5364
5365   /* The constructor name is <init> unless we're dealing with an
5366      anonymous class, in which case the name will be fixed after having
5367      be expanded. */
5368   if (ANONYMOUS_CLASS_P (class_type))
5369     ctor_name = DECL_NAME (class_decl);
5370   else
5371     ctor_name = init_identifier_node;
5372
5373   /* If we're dealing with an inner class constructor, we hide the
5374      this$<n> decl in the name field of its parameter declaration. */
5375   if (PURE_INNER_CLASS_TYPE_P (class_type))
5376     {
5377       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5378       parm = tree_cons (build_current_thisn (class_type),
5379                         build_pointer_type (type), parm);
5380
5381       /* Some more arguments to be hidden here. The values of the local
5382          variables of the outer context that the inner class needs to see. */
5383       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5384                                                      class_type, parm,
5385                                                      &artificial);
5386     }
5387
5388   /* Then if there are any args to be enforced, enforce them now */
5389   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5390     {
5391       sprintf (buffer, "parm%d", i++);
5392       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5393     }
5394
5395   CRAFTED_PARAM_LIST_FIXUP (parm);
5396   decl = create_artificial_method (class_type, flags, void_type_node,
5397                                    ctor_name, parm);
5398   fix_method_argument_names (parm, decl);
5399   /* Now, mark the artificial parameters. */
5400   DECL_FUNCTION_NAP (decl) = artificial;
5401   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5402   DECL_INLINE (decl) = 1;
5403   return decl;
5404 }
5405
5406
5407 /* Fix the constructors. This will be called right after circular
5408    references have been checked. It is necessary to fix constructors
5409    early even if no code generation will take place for that class:
5410    some generated constructor might be required by the class whose
5411    compilation triggered this one to be simply loaded.  */
5412
5413 void
5414 java_fix_constructors (void)
5415 {
5416   tree current;
5417
5418   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5419     {
5420       tree class_type = TREE_TYPE (current);
5421       int saw_ctor = 0;
5422       tree decl;
5423
5424       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5425         continue;
5426
5427       current_class = class_type;
5428       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5429         {
5430           if (DECL_CONSTRUCTOR_P (decl))
5431             {
5432               fix_constructors (decl);
5433               saw_ctor = 1;
5434             }
5435         }
5436
5437       /* Anonymous class constructor can't be generated that early. */
5438       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5439         craft_constructor (current, NULL_TREE);
5440     }
5441 }
5442
5443 /* safe_layout_class just makes sure that we can load a class without
5444    disrupting the current_class, input_file, lineno, etc, information
5445    about the class processed currently.  */
5446
5447 void
5448 safe_layout_class (tree class)
5449 {
5450   tree save_current_class = current_class;
5451   const char *save_input_filename = input_filename;
5452   int save_lineno = input_line;
5453
5454   layout_class (class);
5455
5456   current_class = save_current_class;
5457   input_filename = save_input_filename;
5458   input_line = save_lineno;
5459 }
5460
5461 static tree
5462 jdep_resolve_class (jdep *dep)
5463 {
5464   tree decl;
5465
5466   if (JDEP_RESOLVED_P (dep))
5467     decl = JDEP_RESOLVED_DECL (dep);
5468   else
5469     {
5470       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5471                             JDEP_DECL (dep), JDEP_WFL (dep));
5472       JDEP_RESOLVED (dep, decl);
5473       /* If there is no WFL, that's ok.  We generate this warning
5474          elsewhere.  */
5475       if (decl && JDEP_WFL (dep) != NULL_TREE)
5476         check_deprecation (JDEP_WFL (dep), decl);
5477     }
5478
5479   if (!decl)
5480     complete_class_report_errors (dep);
5481   else if (PURE_INNER_CLASS_DECL_P (decl))
5482     {
5483       tree inner = TREE_TYPE (decl);
5484       if (! CLASS_LOADED_P (inner))
5485         {
5486           safe_layout_class (inner);
5487           if (TYPE_SIZE (inner) == error_mark_node)
5488             TYPE_SIZE (inner) = NULL_TREE;
5489         }
5490       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5491     }
5492   return decl;
5493 }
5494
5495 /* Complete unsatisfied class declaration and their dependencies */
5496
5497 void
5498 java_complete_class (void)
5499 {
5500   tree cclass;
5501   jdeplist *cclassd;
5502   int error_found;
5503   tree type;
5504
5505   /* Process imports */
5506   process_imports ();
5507
5508   /* Reverse things so we have the right order */
5509   ctxp->class_list = nreverse (ctxp->class_list);
5510   ctxp->classd_list = reverse_jdep_list (ctxp);
5511
5512   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5513        cclass && cclassd;
5514        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5515     {
5516       jdep *dep;
5517
5518       /* We keep the compilation unit imports in the class so that
5519          they can be used later to resolve type dependencies that
5520          aren't necessary to solve now. */
5521       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5522       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5523
5524       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5525         {
5526           tree decl;
5527           if (!(decl = jdep_resolve_class (dep)))
5528             continue;
5529
5530           /* Now it's time to patch */
5531           switch (JDEP_KIND (dep))
5532             {
5533             case JDEP_SUPER:
5534               /* Simply patch super */
5535               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5536                 continue;
5537               BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5538                 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5539               break;
5540
5541             case JDEP_FIELD:
5542               {
5543                 /* We do part of the job done in add_field */
5544                 tree field_decl = JDEP_DECL (dep);
5545                 tree field_type = TREE_TYPE (decl);
5546                 if (TREE_CODE (field_type) == RECORD_TYPE)
5547                   field_type = promote_type (field_type);
5548                 TREE_TYPE (field_decl) = field_type;
5549                 DECL_ALIGN (field_decl) = 0;
5550                 DECL_USER_ALIGN (field_decl) = 0;
5551                 layout_decl (field_decl, 0);
5552                 SOURCE_FRONTEND_DEBUG
5553                   (("Completed field/var decl `%s' with `%s'",
5554                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5555                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5556                 break;
5557               }
5558             case JDEP_METHOD:   /* We start patching a method */
5559             case JDEP_METHOD_RETURN:
5560               error_found = 0;
5561               while (1)
5562                 {
5563                   if (decl)
5564                     {
5565                       type = TREE_TYPE(decl);
5566                       if (TREE_CODE (type) == RECORD_TYPE)
5567                         type = promote_type (type);
5568                       JDEP_APPLY_PATCH (dep, type);
5569                       SOURCE_FRONTEND_DEBUG
5570                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5571                            "Completing fct `%s' with ret type `%s'":
5572                            "Completing arg `%s' with type `%s'"),
5573                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5574                                               (JDEP_DECL_WFL (dep))),
5575                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5576                     }
5577                   else
5578                     error_found = 1;
5579                   dep = JDEP_CHAIN (dep);
5580                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5581                     break;
5582                   else
5583                     decl = jdep_resolve_class (dep);
5584                 }
5585               if (!error_found)
5586                 {
5587                   tree mdecl = JDEP_DECL (dep), signature;
5588                   /* Recompute and reset the signature, check first that
5589                      all types are now defined. If they're not,
5590                      don't build the signature. */
5591                   if (check_method_types_complete (mdecl))
5592                     {
5593                       signature = build_java_signature (TREE_TYPE (mdecl));
5594                       set_java_signature (TREE_TYPE (mdecl), signature);
5595                     }
5596                 }
5597               else
5598                 continue;
5599               break;
5600
5601             case JDEP_INTERFACE:
5602               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5603                                                 JDEP_WFL (dep)))
5604                 continue;
5605               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5606               break;
5607
5608             case JDEP_PARM:
5609             case JDEP_VARIABLE:
5610               type = TREE_TYPE(decl);
5611               if (TREE_CODE (type) == RECORD_TYPE)
5612                 type = promote_type (type);
5613               JDEP_APPLY_PATCH (dep, type);
5614               break;
5615
5616             case JDEP_TYPE:
5617               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5618               SOURCE_FRONTEND_DEBUG
5619                 (("Completing a random type dependency on a '%s' node",
5620                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5621               break;
5622
5623             case JDEP_EXCEPTION:
5624               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5625               SOURCE_FRONTEND_DEBUG
5626                 (("Completing `%s' `throws' argument node",
5627                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5628               break;
5629
5630             case JDEP_ANONYMOUS:
5631               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5632               break;
5633
5634             default:
5635               abort ();
5636             }
5637         }
5638     }
5639   return;
5640 }
5641
5642 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5643    array.  */
5644
5645 static tree
5646 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5647 {
5648   tree tname = TYPE_NAME (class_type);
5649   tree resolved_type = TREE_TYPE (class_type);
5650   int array_dims = 0;
5651   tree resolved_type_decl;
5652
5653   if (resolved_type != NULL_TREE)
5654     {
5655       tree resolved_type_decl = TYPE_NAME (resolved_type);
5656       if (resolved_type_decl == NULL_TREE
5657           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5658         {
5659           resolved_type_decl = build_decl (TYPE_DECL,
5660                                            TYPE_NAME (class_type),
5661                                            resolved_type);
5662         }
5663       return resolved_type_decl;
5664     }
5665
5666   /* 1- Check to see if we have an array. If true, find what we really
5667      want to resolve  */
5668   if ((array_dims = build_type_name_from_array_name (tname,
5669                                                      &TYPE_NAME (class_type))))
5670     WFL_STRIP_BRACKET (cl, cl);
5671
5672   /* 2- Resolve the bare type */
5673   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5674                                                decl, cl)))
5675     return NULL_TREE;
5676   resolved_type = TREE_TYPE (resolved_type_decl);
5677
5678   /* 3- If we have an array, reconstruct the array down to its nesting */
5679   if (array_dims)
5680     {
5681       for (; array_dims; array_dims--)
5682         resolved_type = build_java_array_type (resolved_type, -1);
5683       resolved_type_decl = TYPE_NAME (resolved_type);
5684     }
5685   TREE_TYPE (class_type) = resolved_type;
5686   return resolved_type_decl;
5687 }
5688
5689 /* Effectively perform the resolution of class CLASS_TYPE.  DECL or CL
5690    are used to report error messages; CL must either be NULL_TREE or a
5691    WFL wrapping a class.  Do not try to replace TYPE_NAME (class_type)
5692    by a variable, since it is changed by find_in_imports{_on_demand}
5693    and (but it doesn't really matter) qualify_and_find.  */
5694
5695 tree
5696 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5697 {
5698   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5699   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5700   tree decl_result;
5701   htab_t circularity_hash;
5702
5703   if (QUALIFIED_P (TYPE_NAME (class_type)))
5704     {
5705       /* If the type name is of the form `Q . Id', then Q is either a
5706          package name or a class name.  First we try to find Q as a
5707          class and then treat Id as a member type.  If we can't find Q
5708          as a class then we fall through.  */
5709       tree q, left, left_type, right;
5710       breakdown_qualified (&left, &right, TYPE_NAME (class_type));
5711       BUILD_PTR_FROM_NAME (left_type, left);
5712       q = do_resolve_class (enclosing, left_type, decl, cl);
5713       if (q)
5714         {
5715           enclosing = q;
5716           saved_enclosing_type = TREE_TYPE (q);
5717           BUILD_PTR_FROM_NAME (class_type, right);
5718         }
5719     }
5720
5721   if (enclosing)
5722     {
5723       /* This hash table is used to register the classes we're going
5724          through when searching the current class as an inner class, in
5725          order to detect circular references. Remember to free it before
5726          returning the section 0- of this function. */
5727       circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5728                                       NULL);
5729
5730       /* 0- Search in the current class as an inner class.
5731          Maybe some code here should be added to load the class or
5732          something, at least if the class isn't an inner class and ended
5733          being loaded from class file. FIXME. */
5734       while (enclosing)
5735         {
5736           new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5737                                                 &super, class_type);
5738           if (new_class_decl)
5739             break;
5740
5741           /* If we haven't found anything because SUPER reached Object and
5742              ENCLOSING happens to be an innerclass, try the enclosing context. */
5743           if ((!super || super == object_type_node) &&
5744               enclosing && INNER_CLASS_DECL_P (enclosing))
5745             enclosing = DECL_CONTEXT (enclosing);
5746           else
5747             enclosing = NULL_TREE;
5748         }
5749
5750       htab_delete (circularity_hash);
5751
5752       if (new_class_decl)
5753         return new_class_decl;
5754     }
5755
5756   /* 1- Check for the type in single imports. This will change
5757      TYPE_NAME() if something relevant is found */
5758   find_in_imports (saved_enclosing_type, class_type);
5759
5760   /* 2- And check for the type in the current compilation unit */
5761   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5762     {
5763       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5764           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5765         load_class (TYPE_NAME (class_type), 0);
5766       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5767     }
5768
5769   /* 3- Search according to the current package definition */
5770   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5771     {
5772       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5773                                              TYPE_NAME (class_type))))
5774         return new_class_decl;
5775     }
5776
5777   /* 4- Check the import on demands. Don't allow bar.baz to be
5778      imported from foo.* */
5779   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5780     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5781       return NULL_TREE;
5782
5783   /* If found in find_in_imports_on_demand, the type has already been
5784      loaded. */
5785   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5786     return new_class_decl;
5787
5788   /* 5- Try with a name qualified with the package name we've seen so far */
5789   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5790     {
5791       tree package;
5792
5793       /* If there is a current package (ctxp->package), it's the first
5794          element of package_list and we can skip it. */
5795       for (package = (ctxp->package ?
5796                       TREE_CHAIN (package_list) : package_list);
5797            package; package = TREE_CHAIN (package))
5798         if ((new_class_decl = qualify_and_find (class_type,
5799                                                TREE_PURPOSE (package),
5800                                                TYPE_NAME (class_type))))
5801           return new_class_decl;
5802     }
5803
5804   /* 5- Check another compilation unit that bears the name of type */
5805   load_class (TYPE_NAME (class_type), 0);
5806
5807   if (!cl)
5808     cl = lookup_cl (decl);
5809
5810   /* If we don't have a value for CL, then we're being called recursively.
5811      We can't check package access just yet, but it will be taken care of
5812      by the caller. */
5813   if (cl)
5814     {
5815       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true))
5816         return NULL_TREE;
5817     }
5818
5819   /* 6- Last call for a resolution */
5820   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5821
5822   /* The final lookup might have registered a.b.c into a.b$c If we
5823      failed at the first lookup, progressively change the name if
5824      applicable and use the matching DECL instead. */
5825   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5826     {
5827       char *separator;
5828       tree name = TYPE_NAME (class_type);
5829       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
5830
5831       strcpy (namebuffer, IDENTIFIER_POINTER (name));
5832
5833       do {
5834
5835        /* Reach the last '.', and if applicable, replace it by a `$' and
5836           see if this exists as a type. */
5837        if ((separator = strrchr (namebuffer, '.')))
5838          {
5839            *separator = '$';
5840            name = get_identifier (namebuffer);
5841            decl_result = IDENTIFIER_CLASS_VALUE (name);
5842          }
5843       } while (!decl_result && separator);
5844     }
5845   return decl_result;
5846 }
5847
5848 static tree
5849 qualify_and_find (tree class_type, tree package, tree name)
5850 {
5851   tree new_qualified = merge_qualified_name (package, name);
5852   tree new_class_decl;
5853
5854   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5855     load_class (new_qualified, 0);
5856   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5857     {
5858       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5859           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5860         load_class (new_qualified, 0);
5861       TYPE_NAME (class_type) = new_qualified;
5862       return IDENTIFIER_CLASS_VALUE (new_qualified);
5863     }
5864   return NULL_TREE;
5865 }
5866
5867 /* Resolve NAME and lay it out (if not done and if not the current
5868    parsed class). Return a decl node. This function is meant to be
5869    called when type resolution is necessary during the walk pass.  */
5870
5871 static tree
5872 resolve_and_layout (tree something, tree cl)
5873 {
5874   tree decl, decl_type;
5875
5876   /* Don't do that on the current class */
5877   if (something == current_class)
5878     return TYPE_NAME (current_class);
5879
5880   /* Don't do anything for void and other primitive types */
5881   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5882     return NULL_TREE;
5883
5884   /* Pointer types can be reall pointer types or fake pointers. When
5885      finding a real pointer, recheck for primitive types */
5886   if (TREE_CODE (something) == POINTER_TYPE)
5887     {
5888       if (TREE_TYPE (something))
5889         {
5890           something = TREE_TYPE (something);
5891           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5892             return NULL_TREE;
5893         }
5894       else
5895         something = TYPE_NAME (something);
5896     }
5897
5898   /* Don't do anything for arrays of primitive types */
5899   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5900       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5901     return NULL_TREE;
5902
5903   /* Something might be a WFL */
5904   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5905     something = EXPR_WFL_NODE (something);
5906
5907   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5908      TYPE_DECL or a real TYPE */
5909   else if (TREE_CODE (something) != IDENTIFIER_NODE)
5910     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5911             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5912
5913   if (!(decl = resolve_no_layout (something, cl)))
5914     return NULL_TREE;
5915
5916   /* Resolve and layout if necessary */
5917   decl_type = TREE_TYPE (decl);
5918   layout_class_methods (decl_type);
5919   /* Check methods */
5920   if (CLASS_FROM_SOURCE_P (decl_type))
5921     java_check_methods (decl);
5922   /* Layout the type if necessary */
5923   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5924     safe_layout_class (decl_type);
5925
5926   return decl;
5927 }
5928
5929 /* Resolve a class, returns its decl but doesn't perform any
5930    layout. The current parsing context is saved and restored */
5931
5932 static tree
5933 resolve_no_layout (tree name, tree cl)
5934 {
5935   tree ptr, decl;
5936   BUILD_PTR_FROM_NAME (ptr, name);
5937   java_parser_context_save_global ();
5938   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5939   java_parser_context_restore_global ();
5940
5941   return decl;
5942 }
5943
5944 /* Called when reporting errors. Skip the '[]'s in a complex array
5945    type description that failed to be resolved. purify_type_name can't
5946    use an identifier tree.  */
5947
5948 static const char *
5949 purify_type_name (const char *name)
5950 {
5951   int len = strlen (name);
5952   int bracket_found;
5953
5954   STRING_STRIP_BRACKETS (name, len, bracket_found);
5955   if (bracket_found)
5956     {
5957       char *stripped_name = xmemdup (name, len, len+1);
5958       stripped_name [len] = '\0';
5959       return stripped_name;
5960     }
5961   return name;
5962 }
5963
5964 /* The type CURRENT refers to can't be found. We print error messages.  */
5965
5966 static void
5967 complete_class_report_errors (jdep *dep)
5968 {
5969   const char *name;
5970
5971   if (!JDEP_WFL (dep))
5972     return;
5973
5974   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
5975   switch (JDEP_KIND (dep))
5976     {
5977     case JDEP_SUPER:
5978       parse_error_context
5979         (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
5980          purify_type_name (name),
5981          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5982       break;
5983     case JDEP_FIELD:
5984       parse_error_context
5985         (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
5986          purify_type_name (name),
5987          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
5988       break;
5989     case JDEP_METHOD:           /* Covers arguments */
5990       parse_error_context
5991         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
5992          purify_type_name (name),
5993          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
5994          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
5995       break;
5996     case JDEP_METHOD_RETURN:    /* Covers return type */
5997       parse_error_context
5998         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
5999          purify_type_name (name),
6000          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6001       break;
6002     case JDEP_INTERFACE:
6003       parse_error_context
6004         (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
6005          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6006          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6007          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6008       break;
6009     case JDEP_VARIABLE:
6010       parse_error_context
6011         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
6012          purify_type_name (IDENTIFIER_POINTER
6013                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6014          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6015       break;
6016     case JDEP_EXCEPTION:        /* As specified by `throws' */
6017       parse_error_context
6018           (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6019          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6020       break;
6021     default:
6022       /* Fix for -Wall. Just break doing nothing. The error will be
6023          caught later */
6024       break;
6025     }
6026 }
6027
6028 /* Return a static string containing the DECL prototype string. If
6029    DECL is a constructor, use the class name instead of the form
6030    <init> */
6031
6032 static const char *
6033 get_printable_method_name (tree decl)
6034 {
6035   const char *to_return;
6036   tree name = NULL_TREE;
6037
6038   if (DECL_CONSTRUCTOR_P (decl))
6039     {
6040       name = DECL_NAME (decl);
6041       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6042     }
6043
6044   to_return = lang_printable_name (decl, 0);
6045   if (DECL_CONSTRUCTOR_P (decl))
6046     DECL_NAME (decl) = name;
6047
6048   return to_return;
6049 }
6050
6051 /* Track method being redefined inside the same class. As a side
6052    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6053    function it's a FWL, so we can track errors more accurately.)  */
6054
6055 static int
6056 check_method_redefinition (tree class, tree method)
6057 {
6058   tree redef, sig;
6059
6060   /* There's no need to verify <clinit> and finit$ and instinit$ */
6061   if (DECL_CLINIT_P (method)
6062       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6063     return 0;
6064
6065   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6066   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6067     {
6068       if (redef == method)
6069         break;
6070       if (DECL_NAME (redef) == DECL_NAME (method)
6071           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6072           && !DECL_ARTIFICIAL (method))
6073         {
6074           parse_error_context
6075             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6076              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6077              get_printable_method_name (redef));
6078           return 1;
6079         }
6080     }
6081   return 0;
6082 }
6083
6084 /* Return 1 if check went ok, 0 otherwise.  */
6085 static int
6086 check_abstract_method_definitions (int do_interface, tree class_decl,
6087                                    tree type)
6088 {
6089   tree class = TREE_TYPE (class_decl);
6090   tree method, end_type;
6091   int ok = 1;
6092
6093   end_type = (do_interface ? object_type_node : type);
6094   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6095     {
6096       tree other_super, other_method, method_sig, method_name;
6097       int found = 0;
6098       int end_type_reached = 0;
6099
6100       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6101         continue;
6102
6103       /* Now verify that somewhere in between TYPE and CLASS,
6104          abstract method METHOD gets a non abstract definition
6105          that is inherited by CLASS.  */
6106
6107       method_sig = build_java_signature (TREE_TYPE (method));
6108       method_name = DECL_NAME (method);
6109       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6110         method_name = EXPR_WFL_NODE (method_name);
6111
6112       other_super = class;
6113       do {
6114         if (other_super == end_type)
6115           end_type_reached = 1;
6116
6117         /* Method search */
6118         for (other_method = TYPE_METHODS (other_super); other_method;
6119             other_method = TREE_CHAIN (other_method))
6120           {
6121             tree s = build_java_signature (TREE_TYPE (other_method));
6122             tree other_name = DECL_NAME (other_method);
6123
6124             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6125               other_name = EXPR_WFL_NODE (other_name);
6126             if (!DECL_CLINIT_P (other_method)
6127                 && !DECL_CONSTRUCTOR_P (other_method)
6128                 && method_name == other_name
6129                 && method_sig == s
6130                 && !METHOD_ABSTRACT (other_method))
6131              {
6132                found = 1;
6133                break;
6134              }
6135           }
6136         other_super = CLASSTYPE_SUPER (other_super);
6137       } while (!end_type_reached);
6138
6139       /* Report that abstract METHOD didn't find an implementation
6140          that CLASS can use. */
6141       if (!found)
6142         {
6143           char *t = xstrdup (lang_printable_name
6144                             (TREE_TYPE (TREE_TYPE (method)), 0));
6145           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6146
6147           parse_error_context
6148             (lookup_cl (class_decl),
6149              "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",
6150              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6151              t, lang_printable_name (method, 0),
6152              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6153               "interface" : "class"),
6154              IDENTIFIER_POINTER (ccn),
6155              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6156              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6157           ok = 0;
6158           free (t);
6159         }
6160     }
6161
6162   if (ok && do_interface)
6163     {
6164       /* Check for implemented interfaces. */
6165       int i;
6166       tree vector = TYPE_BINFO_BASETYPES (type);
6167       for (i = 1; ok && vector && i < TREE_VEC_LENGTH (vector); i++)
6168         {
6169           tree super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6170           ok = check_abstract_method_definitions (1, class_decl, super);
6171         }
6172     }
6173
6174   return ok;
6175 }
6176
6177 /* Check that CLASS_DECL somehow implements all inherited abstract
6178    methods.  */
6179
6180 static void
6181 java_check_abstract_method_definitions (tree class_decl)
6182 {
6183   tree class = TREE_TYPE (class_decl);
6184   tree super, vector;
6185   int i;
6186
6187   if (CLASS_ABSTRACT (class_decl))
6188     return;
6189
6190   /* Check for inherited types */
6191   super = class;
6192   do {
6193     super = CLASSTYPE_SUPER (super);
6194     check_abstract_method_definitions (0, class_decl, super);
6195   } while (super != object_type_node);
6196
6197   /* Check for implemented interfaces. */
6198   vector = TYPE_BINFO_BASETYPES (class);
6199   for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
6200     {
6201       super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6202       check_abstract_method_definitions (1, class_decl, super);
6203     }
6204 }
6205
6206 /* Check all the types method DECL uses and return 1 if all of them
6207    are now complete, 0 otherwise. This is used to check whether its
6208    safe to build a method signature or not.  */
6209
6210 static int
6211 check_method_types_complete (tree decl)
6212 {
6213   tree type = TREE_TYPE (decl);
6214   tree args;
6215
6216   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6217     return 0;
6218
6219   args = TYPE_ARG_TYPES (type);
6220   if (TREE_CODE (type) == METHOD_TYPE)
6221     args = TREE_CHAIN (args);
6222   for (; args != end_params_node; args = TREE_CHAIN (args))
6223     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6224       return 0;
6225
6226   return 1;
6227 }
6228
6229 /* Visible interface to check methods contained in CLASS_DECL */
6230
6231 void
6232 java_check_methods (tree class_decl)
6233 {
6234   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6235     return;
6236
6237   if (CLASS_INTERFACE (class_decl))
6238     java_check_abstract_methods (class_decl);
6239   else
6240     java_check_regular_methods (class_decl);
6241
6242   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6243 }
6244
6245 /* Like not_accessible_p, but doesn't refer to the current class at
6246    all.  */
6247 static bool
6248 hack_is_accessible_p (tree member, tree from_where)
6249 {
6250   int flags = get_access_flags_from_decl (member);
6251
6252   if (from_where == DECL_CONTEXT (member)
6253       || (flags & ACC_PUBLIC))
6254     return true;
6255
6256   if ((flags & ACC_PROTECTED))
6257     {
6258       if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6259         return true;
6260     }
6261
6262   if ((flags & ACC_PRIVATE))
6263     return false;
6264
6265   /* Package private, or protected.  */
6266   return in_same_package (TYPE_NAME (from_where),
6267                           TYPE_NAME (DECL_CONTEXT (member)));
6268 }
6269
6270 /* Check all the methods of CLASS_DECL. Methods are first completed
6271    then checked according to regular method existence rules.  If no
6272    constructor for CLASS_DECL were encountered, then build its
6273    declaration.  */
6274 static void
6275 java_check_regular_methods (tree class_decl)
6276 {
6277   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6278   tree method;
6279   tree class = TREE_TYPE (class_decl);
6280   tree found = NULL_TREE;
6281   tree mthrows;
6282
6283   /* It is not necessary to check methods defined in java.lang.Object */
6284   if (class == object_type_node)
6285     return;
6286
6287   if (!TYPE_NVIRTUALS (class))
6288     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6289
6290   /* Should take interfaces into account. FIXME */
6291   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6292     {
6293       tree sig;
6294       tree method_wfl = DECL_FUNCTION_WFL (method);
6295       int aflags;
6296
6297       /* Check for redefinitions */
6298       if (check_method_redefinition (class, method))
6299         continue;
6300
6301       /* We verify things thrown by the method.  They must inherit from
6302          java.lang.Throwable.  */
6303       for (mthrows = DECL_FUNCTION_THROWS (method);
6304            mthrows; mthrows = TREE_CHAIN (mthrows))
6305         {
6306           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6307             parse_error_context
6308               (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6309                IDENTIFIER_POINTER
6310                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6311         }
6312
6313       /* If we see one constructor a mark so we don't generate the
6314          default one.  Also skip other verifications: constructors
6315          can't be inherited hence hidden or overridden.  */
6316       if (DECL_CONSTRUCTOR_P (method))
6317         {
6318           saw_constructor = 1;
6319           continue;
6320         }
6321
6322       sig = build_java_argument_signature (TREE_TYPE (method));
6323       found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6324                                               SEARCH_SUPER | SEARCH_INTERFACE);
6325
6326       /* Inner class can't declare static methods */
6327       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6328         {
6329           char *t = xstrdup (lang_printable_name (class, 0));
6330           parse_error_context
6331             (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6332              lang_printable_name (method, 0), t);
6333           free (t);
6334         }
6335
6336       /* Nothing overrides or it's a private method. */
6337       if (!found)
6338         continue;
6339       if (METHOD_PRIVATE (found))
6340         {
6341           found = NULL_TREE;
6342           continue;
6343         }
6344
6345       /* If `found' is declared in an interface, make sure the
6346          modifier matches. */
6347       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6348           && clinit_identifier_node != DECL_NAME (found)
6349           && !METHOD_PUBLIC (method))
6350         {
6351           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6352           parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6353                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6354                                lang_printable_name (method, 0),
6355                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6356         }
6357
6358       /* Can't override a method with the same name and different return
6359          types. */
6360       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6361         {
6362           char *t = xstrdup
6363             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6364           parse_error_context
6365             (method_wfl,
6366              "Method `%s' was defined with return type `%s' in class `%s'",
6367              lang_printable_name (found, 0), t,
6368              IDENTIFIER_POINTER
6369                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6370           free (t);
6371         }
6372
6373       aflags = get_access_flags_from_decl (found);
6374
6375       /* Can't override final. Can't override static. */
6376       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6377         {
6378           /* Static *can* override static */
6379           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6380             continue;
6381           parse_error_context
6382             (method_wfl,
6383              "%s methods can't be overridden. Method `%s' is %s in class `%s'",
6384              (METHOD_FINAL (found) ? "Final" : "Static"),
6385              lang_printable_name (found, 0),
6386              (METHOD_FINAL (found) ? "final" : "static"),
6387              IDENTIFIER_POINTER
6388                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6389           continue;
6390         }
6391
6392       /* Static method can't override instance method. */
6393       if (METHOD_STATIC (method))
6394         {
6395           parse_error_context
6396             (method_wfl,
6397              "Instance methods can't be overridden by a static method. Method `%s' is an instance method in class `%s'",
6398              lang_printable_name (found, 0),
6399              IDENTIFIER_POINTER
6400                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6401           continue;
6402         }
6403
6404       /* - Overriding/hiding public must be public
6405          - Overriding/hiding protected must be protected or public
6406          - If the overridden or hidden method has default (package)
6407            access, then the overriding or hiding method must not be
6408            private; otherwise, a compile-time error occurs.  If
6409            `found' belongs to an interface, things have been already
6410            taken care of.  */
6411       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6412           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6413               || (METHOD_PROTECTED (found)
6414                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6415               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6416                   && METHOD_PRIVATE (method))))
6417         {
6418           parse_error_context
6419             (method_wfl,
6420              "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6421              (METHOD_PUBLIC (method) ? "public" :
6422               (METHOD_PRIVATE (method) ? "private" : "protected")),
6423              IDENTIFIER_POINTER (DECL_NAME
6424                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6425           continue;
6426         }
6427
6428       /* Check this method against all the other implementations it
6429          overrides.  Here we only check the class hierarchy; the rest
6430          of the checking is done later.  If this method is just a
6431          Miranda method, we can skip the check.  */
6432       if (! METHOD_INVISIBLE (method))
6433         check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6434     }
6435
6436   /* The above throws clause check only looked at superclasses.  Now
6437      we must also make sure that all methods declared in interfaces
6438      have compatible throws clauses.  FIXME: there are more efficient
6439      ways to organize this checking; we should implement one.  */
6440   check_interface_throws_clauses (class, class);
6441
6442   if (!TYPE_NVIRTUALS (class))
6443     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6444
6445   /* Search for inherited abstract method not yet implemented in this
6446      class.  */
6447   java_check_abstract_method_definitions (class_decl);
6448
6449   if (!saw_constructor)
6450     abort ();
6451 }
6452
6453 /* Check to make sure that all the methods in all the interfaces
6454    implemented by CLASS_DECL are compatible with the concrete
6455    implementations available in CHECK_CLASS_DECL.  */
6456 static void
6457 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6458 {
6459   for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6460     {
6461       tree bases = TYPE_BINFO_BASETYPES (class_decl);
6462       int iface_len = TREE_VEC_LENGTH (bases) - 1;
6463       int i;
6464
6465       for (i = iface_len; i > 0; --i)
6466         {
6467           tree interface = BINFO_TYPE (TREE_VEC_ELT (bases, i));
6468           tree iface_method;
6469
6470           for (iface_method = TYPE_METHODS (interface);
6471                iface_method != NULL_TREE;
6472                iface_method = TREE_CHAIN (iface_method))
6473             {
6474               tree sig, method;
6475
6476               /* First look for a concrete method implemented or
6477                  inherited by this class.  No need to search
6478                  interfaces here, since we're already looking through
6479                  all of them.  */
6480               sig = build_java_argument_signature (TREE_TYPE (iface_method));
6481               method
6482                 = lookup_argument_method_generic (check_class_decl,
6483                                                   DECL_NAME (iface_method),
6484                                                   sig, SEARCH_VISIBLE);
6485               /* If we don't find an implementation, that is ok.  Any
6486                  potential errors from that are diagnosed elsewhere.
6487                  Also, multiple inheritance with conflicting throws
6488                  clauses is fine in the absence of a concrete
6489                  implementation.  */
6490               if (method != NULL_TREE && !METHOD_ABSTRACT (method))
6491                 {
6492                   tree method_wfl = DECL_FUNCTION_WFL (method);
6493                   check_throws_clauses (method, method_wfl, iface_method);
6494                 }
6495             }
6496
6497           /* Now check superinterfaces.  */
6498           check_interface_throws_clauses (check_class_decl, interface);
6499         }
6500     }
6501 }
6502
6503 /* Check throws clauses of a method against the clauses of all the
6504    methods it overrides.  We do this by searching up the class
6505    hierarchy, examining all matching accessible methods.  */
6506 static void
6507 check_concrete_throws_clauses (tree class, tree self_method,
6508                                tree name, tree signature)
6509 {
6510   tree method = lookup_argument_method_generic (class, name, signature,
6511                                                 SEARCH_SUPER | SEARCH_VISIBLE);
6512   while (method != NULL_TREE)
6513     {
6514       if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6515         check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6516                               method);
6517
6518       method = lookup_argument_method_generic (DECL_CONTEXT (method),
6519                                                name, signature,
6520                                                SEARCH_SUPER | SEARCH_VISIBLE);
6521     }
6522 }
6523
6524 /* Generate an error if the `throws' clause of METHOD (if any) is
6525    incompatible with the `throws' clause of FOUND (if any).  */
6526 static void
6527 check_throws_clauses (tree method, tree method_wfl, tree found)
6528 {
6529   tree mthrows;
6530
6531   /* Can't check these things with class loaded from bytecode. FIXME */
6532   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6533     return;
6534
6535   for (mthrows = DECL_FUNCTION_THROWS (method);
6536        mthrows; mthrows = TREE_CHAIN (mthrows))
6537     {
6538       tree fthrows;
6539
6540       /* We don't verify unchecked expressions */
6541       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6542         continue;
6543       /* Checked expression must be compatible */
6544       for (fthrows = DECL_FUNCTION_THROWS (found);
6545            fthrows; fthrows = TREE_CHAIN (fthrows))
6546         {
6547           if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6548             break;
6549         }
6550       if (!fthrows)
6551         {
6552           parse_error_context
6553             (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'",
6554              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6555              lang_printable_name (found, 0),
6556              IDENTIFIER_POINTER
6557              (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6558         }
6559     }
6560 }
6561
6562 /* Check abstract method of interface INTERFACE */
6563 static void
6564 java_check_abstract_methods (tree interface_decl)
6565 {
6566   int i, n;
6567   tree method, basetype_vec, found;
6568   tree interface = TREE_TYPE (interface_decl);
6569
6570   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6571     {
6572       /* 2- Check for double definition inside the defining interface */
6573       if (check_method_redefinition (interface, method))
6574         continue;
6575
6576       /* 3- Overriding is OK as far as we preserve the return type.  */
6577       found = lookup_java_interface_method2 (interface, method);
6578       if (found)
6579         {
6580           char *t;
6581           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6582           parse_error_context
6583             (DECL_FUNCTION_WFL (found),
6584              "Method `%s' was defined with return type `%s' in class `%s'",
6585              lang_printable_name (found, 0), t,
6586              IDENTIFIER_POINTER
6587                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6588           free (t);
6589           continue;
6590         }
6591     }
6592
6593   /* 4- Inherited methods can't differ by their returned types */
6594   if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6595     return;
6596   n = TREE_VEC_LENGTH (basetype_vec);
6597   for (i = 0; i < n; i++)
6598     {
6599       tree sub_interface_method, sub_interface;
6600       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6601       if (!vec_elt)
6602         continue;
6603       sub_interface = BINFO_TYPE (vec_elt);
6604       for (sub_interface_method = TYPE_METHODS (sub_interface);
6605            sub_interface_method;
6606            sub_interface_method = TREE_CHAIN (sub_interface_method))
6607         {
6608           found = lookup_java_interface_method2 (interface,
6609                                                  sub_interface_method);
6610           if (found && (found != sub_interface_method))
6611             {
6612               parse_error_context
6613                 (lookup_cl (sub_interface_method),
6614                  "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6615                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6616                  lang_printable_name (found, 0),
6617                  IDENTIFIER_POINTER
6618                    (DECL_NAME (TYPE_NAME
6619                                (DECL_CONTEXT (sub_interface_method)))),
6620                  IDENTIFIER_POINTER
6621                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6622             }
6623         }
6624     }
6625 }
6626
6627 /* Lookup methods in interfaces using their name and partial
6628    signature. Return a matching method only if their types differ.  */
6629
6630 static tree
6631 lookup_java_interface_method2 (tree class, tree method_decl)
6632 {
6633   int i, n;
6634   tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6635
6636   if (!basetype_vec)
6637     return NULL_TREE;
6638
6639   n = TREE_VEC_LENGTH (basetype_vec);
6640   for (i = 0; i < n; i++)
6641     {
6642       tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6643       if ((BINFO_TYPE (vec_elt) != object_type_node)
6644           && (to_return =
6645               lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6646         return to_return;
6647     }
6648   for (i = 0; i < n; i++)
6649     {
6650       to_return = lookup_java_interface_method2
6651         (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6652       if (to_return)
6653         return to_return;
6654     }
6655
6656   return NULL_TREE;
6657 }
6658
6659 /* Lookup method using their name and partial signature. Return a
6660    matching method only if their types differ.  */
6661
6662 static tree
6663 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6664 {
6665   tree method, method_signature, method_name, method_type, name;
6666
6667   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6668   name = DECL_NAME (method_decl);
6669   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6670                  EXPR_WFL_NODE (name) : name);
6671   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6672
6673   while (clas != NULL_TREE)
6674     {
6675       for (method = TYPE_METHODS (clas);
6676            method != NULL_TREE;  method = TREE_CHAIN (method))
6677         {
6678           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6679           tree name = DECL_NAME (method);
6680           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6681                EXPR_WFL_NODE (name) : name) == method_name
6682               && method_sig == method_signature
6683               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6684             return method;
6685         }
6686       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6687     }
6688   return NULL_TREE;
6689 }
6690
6691 /* Return the line that matches DECL line number, and try its best to
6692    position the column number. Used during error reports.  */
6693
6694 static GTY(()) tree cl_v;
6695 static tree
6696 lookup_cl (tree decl)
6697 {
6698   char *line, *found;
6699
6700   if (!decl)
6701     return NULL_TREE;
6702
6703   if (cl_v == NULL_TREE)
6704     {
6705       cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6706     }
6707
6708   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6709   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6710
6711   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6712                             EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6713
6714   found = strstr ((const char *)line,
6715                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6716   if (found)
6717     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6718
6719   return cl_v;
6720 }
6721
6722 /* Look for a simple name in the single-type import list */
6723
6724 static tree
6725 find_name_in_single_imports (tree name)
6726 {
6727   tree node;
6728
6729   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6730     if (TREE_VALUE (node) == name)
6731       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6732
6733   return NULL_TREE;
6734 }
6735
6736 /* Process all single-type import. */
6737
6738 static int
6739 process_imports (void)
6740 {
6741   tree import;
6742   int error_found;
6743
6744   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6745     {
6746       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6747       char *original_name;
6748
6749       original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6750                                IDENTIFIER_LENGTH (to_be_found),
6751                                IDENTIFIER_LENGTH (to_be_found) + 1);
6752
6753       /* Don't load twice something already defined. */
6754       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6755         continue;
6756
6757       while (1)
6758         {
6759           tree left;
6760
6761           QUALIFIED_P (to_be_found) = 1;
6762           load_class (to_be_found, 0);
6763           error_found =
6764             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true);
6765
6766           /* We found it, we can bail out */
6767           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6768             {
6769               check_deprecation (TREE_PURPOSE (import),
6770                                  IDENTIFIER_CLASS_VALUE (to_be_found));
6771               break;
6772             }
6773
6774           /* We haven't found it. Maybe we're trying to access an
6775              inner class.  The only way for us to know is to try again
6776              after having dropped a qualifier. If we can't break it further,
6777              we have an error. */
6778           if (breakdown_qualified (&left, NULL, to_be_found))
6779             break;
6780
6781           to_be_found = left;
6782         }
6783       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6784         {
6785           parse_error_context (TREE_PURPOSE (import),
6786                                "Class or interface `%s' not found in import",
6787                                original_name);
6788           error_found = 1;
6789         }
6790
6791       free (original_name);
6792       if (error_found)
6793         return 1;
6794     }
6795   return 0;
6796 }
6797
6798 /* Possibly find and mark a class imported by a single-type import
6799    statement.  */
6800
6801 static void
6802 find_in_imports (tree enclosing_type, tree class_type)
6803 {
6804   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6805                  ctxp->import_list);
6806   while (import)
6807     {
6808       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6809         {
6810           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6811           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6812           return;
6813         }
6814       import = TREE_CHAIN (import);
6815     }
6816 }
6817
6818 static int
6819 note_possible_classname (const char *name, int len)
6820 {
6821   tree node;
6822   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6823     len = len - 5;
6824   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6825     len = len - 6;
6826   else
6827     return 0;
6828   node = ident_subst (name, len, "", '/', '.', "");
6829   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6830   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6831   return 1;
6832 }
6833
6834 /* Read a import directory, gathering potential match for further type
6835    references. Indifferently reads a filesystem or a ZIP archive
6836    directory.  */
6837
6838 static void
6839 read_import_dir (tree wfl)
6840 {
6841   tree package_id = EXPR_WFL_NODE (wfl);
6842   const char *package_name = IDENTIFIER_POINTER (package_id);
6843   int package_length = IDENTIFIER_LENGTH (package_id);
6844   DIR *dirp = NULL;
6845   JCF *saved_jcf = current_jcf;
6846
6847   int found = 0;
6848   int k;
6849   void *entry;
6850   struct buffer filename[1];
6851
6852   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6853     return;
6854   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6855
6856   BUFFER_INIT (filename);
6857   buffer_grow (filename, package_length + 100);
6858
6859   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6860     {
6861       const char *entry_name = jcf_path_name (entry);
6862       int entry_length = strlen (entry_name);
6863       if (jcf_path_is_zipfile (entry))
6864         {
6865           ZipFile *zipf;
6866           buffer_grow (filename, entry_length);
6867           memcpy (filename->data, entry_name, entry_length - 1);
6868           filename->data[entry_length-1] = '\0';
6869           zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6870           if (zipf == NULL)
6871             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6872           else
6873             {
6874               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6875               BUFFER_RESET (filename);
6876               for (k = 0; k < package_length; k++)
6877                 {
6878                   char ch = package_name[k];
6879                   *filename->ptr++ = ch == '.' ? '/' : ch;
6880                 }
6881               *filename->ptr++ = '/';
6882
6883               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
6884                 {
6885                   const char *current_entry = ZIPDIR_FILENAME (zipd);
6886                   int current_entry_len = zipd->filename_length;
6887
6888                   if (current_entry_len >= BUFFER_LENGTH (filename)
6889                       && strncmp (filename->data, current_entry,
6890                                   BUFFER_LENGTH (filename)) != 0)
6891                     continue;
6892                   found |= note_possible_classname (current_entry,
6893                                                     current_entry_len);
6894                 }
6895             }
6896         }
6897       else
6898         {
6899           BUFFER_RESET (filename);
6900           buffer_grow (filename, entry_length + package_length + 4);
6901           strcpy (filename->data, entry_name);
6902           filename->ptr = filename->data + entry_length;
6903           for (k = 0; k < package_length; k++)
6904             {
6905               char ch = package_name[k];
6906               *filename->ptr++ = ch == '.' ? '/' : ch;
6907             }
6908           *filename->ptr = '\0';
6909
6910           dirp = opendir (filename->data);
6911           if (dirp == NULL)
6912             continue;
6913           *filename->ptr++ = '/';
6914           for (;;)
6915             {
6916               int len;
6917               const char *d_name;
6918               struct dirent *direntp = readdir (dirp);
6919               if (!direntp)
6920                 break;
6921               d_name = direntp->d_name;
6922               len = strlen (direntp->d_name);
6923               buffer_grow (filename, len+1);
6924               strcpy (filename->ptr, d_name);
6925               found |= note_possible_classname (filename->data + entry_length,
6926                                                 package_length+len+1);
6927             }
6928           if (dirp)
6929             closedir (dirp);
6930         }
6931     }
6932
6933   free (filename->data);
6934
6935   /* Here we should have a unified way of retrieving an entry, to be
6936      indexed. */
6937   if (!found)
6938     {
6939       static int first = 1;
6940       if (first)
6941         {
6942           error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
6943           java_error_count++;
6944           first = 0;
6945         }
6946       else
6947         parse_error_context (wfl, "Package `%s' not found in import",
6948                              package_name);
6949       current_jcf = saved_jcf;
6950       return;
6951     }
6952   current_jcf = saved_jcf;
6953 }
6954
6955 /* Possibly find a type in the import on demands specified
6956    types. Returns 1 if an error occurred, 0 otherwise. Run through the
6957    entire list, to detected potential double definitions.  */
6958
6959 static int
6960 find_in_imports_on_demand (tree enclosing_type, tree class_type)
6961 {
6962   tree class_type_name = TYPE_NAME (class_type);
6963   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
6964                   ctxp->import_demand_list);
6965   tree cl = NULL_TREE;
6966   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
6967   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
6968   tree node;
6969
6970   for (; import; import = TREE_CHAIN (import))
6971     {
6972       int saved_lineno = input_line;
6973       int access_check;
6974       const char *id_name;
6975       tree decl, type_name_copy;
6976
6977       obstack_grow (&temporary_obstack,
6978                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
6979                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
6980       obstack_1grow (&temporary_obstack, '.');
6981       obstack_grow0 (&temporary_obstack,
6982                      IDENTIFIER_POINTER (class_type_name),
6983                      IDENTIFIER_LENGTH (class_type_name));
6984       id_name = obstack_finish (&temporary_obstack);
6985
6986       if (! (node = maybe_get_identifier (id_name)))
6987         continue;
6988
6989       /* Setup lineno so that it refers to the line of the import (in
6990          case we parse a class file and encounter errors */
6991       input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
6992
6993       type_name_copy = TYPE_NAME (class_type);
6994       TYPE_NAME (class_type) = node;
6995       QUALIFIED_P (node) = 1;
6996       decl = IDENTIFIER_CLASS_VALUE (node);
6997       access_check = -1;
6998       /* If there is no DECL set for the class or if the class isn't
6999          loaded and not seen in source yet, then load */
7000       if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
7001                     && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
7002         {
7003           load_class (node, 0);
7004           decl = IDENTIFIER_CLASS_VALUE (node);
7005         }
7006       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7007         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7008                                                false);
7009       else
7010         /* 6.6.1: Inner classes are subject to member access rules. */
7011         access_check = 0;
7012
7013       input_line = saved_lineno;
7014
7015       /* If the loaded class is not accessible or couldn't be loaded,
7016          we restore the original TYPE_NAME and process the next
7017          import. */
7018       if (access_check || !decl)
7019         {
7020           TYPE_NAME (class_type) = type_name_copy;
7021           continue;
7022         }
7023
7024       /* If the loaded class is accessible, we keep a tab on it to
7025          detect and report multiple inclusions. */
7026       if (IS_A_CLASSFILE_NAME (node))
7027         {
7028           if (seen_once < 0)
7029             {
7030               cl = TREE_PURPOSE (import);
7031               seen_once = 1;
7032             }
7033           else if (seen_once >= 0)
7034             {
7035               tree location = (cl ? cl : TREE_PURPOSE (import));
7036               tree package = (cl ? EXPR_WFL_NODE (cl) :
7037                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
7038               seen_once++;
7039               parse_error_context
7040                 (location,
7041                  "Type `%s' also potentially defined in package `%s'",
7042                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7043                  IDENTIFIER_POINTER (package));
7044             }
7045         }
7046       to_return = access_check;
7047     }
7048
7049   if (seen_once == 1)
7050     return to_return;
7051   else
7052     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7053 }
7054
7055 /* Add package NAME to the list of packages encountered so far. To
7056    speed up class lookup in do_resolve_class, we make sure a
7057    particular package is added only once.  */
7058
7059 static void
7060 register_package (tree name)
7061 {
7062   static htab_t pht;
7063   void **e;
7064
7065   if (pht == NULL)
7066     pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
7067
7068   e = htab_find_slot (pht, name, INSERT);
7069   if (*e == NULL)
7070     {
7071       package_list = chainon (package_list, build_tree_list (name, NULL));
7072       *e = name;
7073     }
7074 }
7075
7076 static tree
7077 resolve_package (tree pkg, tree *next, tree *type_name)
7078 {
7079   tree current;
7080   tree decl = NULL_TREE;
7081   *type_name = NULL_TREE;
7082
7083   /* The trick is to determine when the package name stops and were
7084      the name of something contained in the package starts. Then we
7085      return a fully qualified name of what we want to get. */
7086
7087   *next = EXPR_WFL_QUALIFICATION (pkg);
7088
7089   /* Try to progressively construct a type name */
7090   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7091     for (current = EXPR_WFL_QUALIFICATION (pkg);
7092          current; current = TREE_CHAIN (current))
7093       {
7094         /* If we don't have what we're expecting, exit now. TYPE_NAME
7095            will be null and the error caught later. */
7096         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7097           break;
7098         *type_name =
7099           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7100         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7101           {
7102             /* resolve_package should be used in a loop, hence we
7103                point at this one to naturally process the next one at
7104                the next iteration. */
7105             *next = current;
7106             break;
7107           }
7108       }
7109   return decl;
7110 }
7111
7112
7113 /* Check accessibility of inner classes according to member access rules.
7114    DECL is the inner class, ENCLOSING_DECL is the class from which the
7115    access is being attempted. */
7116
7117 static void
7118 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7119 {
7120   const char *access;
7121   tree enclosing_decl_type;
7122
7123   /* We don't issue an error message when CL is null. CL can be null
7124      as a result of processing a JDEP crafted by source_start_java_method
7125      for the purpose of patching its parm decl. But the error would
7126      have been already trapped when fixing the method's signature.
7127      DECL can also be NULL in case of earlier errors. */
7128   if (!decl || !cl)
7129     return;
7130
7131   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7132
7133   if (CLASS_PRIVATE (decl))
7134     {
7135       /* Access is permitted only within the body of the top-level
7136          class in which DECL is declared. */
7137       tree top_level = decl;
7138       while (DECL_CONTEXT (top_level))
7139         top_level = DECL_CONTEXT (top_level);
7140       while (DECL_CONTEXT (enclosing_decl))
7141         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7142       if (top_level == enclosing_decl)
7143         return;
7144       access = "private";
7145     }
7146   else if (CLASS_PROTECTED (decl))
7147     {
7148       tree decl_context;
7149       /* Access is permitted from within the same package... */
7150       if (in_same_package (decl, enclosing_decl))
7151         return;
7152
7153       /* ... or from within the body of a subtype of the context in which
7154          DECL is declared. */
7155       decl_context = DECL_CONTEXT (decl);
7156       while (enclosing_decl)
7157         {
7158           if (CLASS_INTERFACE (decl))
7159             {
7160               if (interface_of_p (TREE_TYPE (decl_context),
7161                                   enclosing_decl_type))
7162                 return;
7163             }
7164           else
7165             {
7166               /* Eww. The order of the arguments is different!! */
7167               if (inherits_from_p (enclosing_decl_type,
7168                                    TREE_TYPE (decl_context)))
7169                 return;
7170             }
7171           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7172         }
7173       access = "protected";
7174     }
7175   else if (! CLASS_PUBLIC (decl))
7176     {
7177       /* Access is permitted only from within the same package as DECL. */
7178       if (in_same_package (decl, enclosing_decl))
7179         return;
7180       access = "non-public";
7181     }
7182   else
7183     /* Class is public. */
7184     return;
7185
7186   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7187                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7188                        lang_printable_name (decl, 0), access);
7189 }
7190
7191 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7192    foreign package, it must be PUBLIC. Return 0 if no access
7193    violations were found, 1 otherwise. If VERBOSE is true and an error
7194    was found, it is reported and accounted for.  */
7195
7196 static int
7197 check_pkg_class_access (tree class_name, tree cl, bool verbose)
7198 {
7199   tree type;
7200
7201   if (!IDENTIFIER_CLASS_VALUE (class_name))
7202     return 0;
7203
7204   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7205     return 0;
7206
7207   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7208     {
7209       /* Access to a private class within the same package is
7210          allowed. */
7211       tree l, r;
7212       breakdown_qualified (&l, &r, class_name);
7213       if (!QUALIFIED_P (class_name) && !ctxp->package)
7214         /* Both in the empty package. */
7215         return 0;
7216       if (l == ctxp->package)
7217         /* Both in the same package. */
7218         return 0;
7219
7220       if (verbose)
7221         parse_error_context
7222           (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7223            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7224            IDENTIFIER_POINTER (class_name));
7225       return 1;
7226     }
7227   return 0;
7228 }
7229
7230 /* Local variable declaration. */
7231
7232 static void
7233 declare_local_variables (int modifier, tree type, tree vlist)
7234 {
7235   tree decl, current, saved_type;
7236   tree type_wfl = NULL_TREE;
7237   int must_chain = 0;
7238   int final_p = 0;
7239
7240   /* Push a new block if statements were seen between the last time we
7241      pushed a block and now. Keep a count of blocks to close */
7242   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7243     {
7244       tree b = enter_block ();
7245       BLOCK_IS_IMPLICIT (b) = 1;
7246     }
7247
7248   if (modifier)
7249     {
7250       size_t i;
7251       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7252         if (1 << i & modifier)
7253           break;
7254       if (modifier == ACC_FINAL)
7255         final_p = 1;
7256       else
7257         {
7258           parse_error_context
7259             (ctxp->modifier_ctx [i],
7260              "Only `final' is allowed as a local variables modifier");
7261           return;
7262         }
7263     }
7264
7265   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7266      hold the TYPE value if a new incomplete has to be created (as
7267      opposed to being found already existing and reused). */
7268   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7269
7270   /* If TYPE is fully resolved and we don't have a reference, make one */
7271   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7272
7273   /* Go through all the declared variables */
7274   for (current = vlist, saved_type = type; current;
7275        current = TREE_CHAIN (current), type = saved_type)
7276     {
7277       tree other, real_type;
7278       tree wfl  = TREE_PURPOSE (current);
7279       tree name = EXPR_WFL_NODE (wfl);
7280       tree init = TREE_VALUE (current);
7281
7282       /* Process NAME, as it may specify extra dimension(s) for it */
7283       type = build_array_from_name (type, type_wfl, name, &name);
7284
7285       /* Variable redefinition check */
7286       if ((other = lookup_name_in_blocks (name)))
7287         {
7288           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7289                                        DECL_SOURCE_LINE (other));
7290           continue;
7291         }
7292
7293       /* Type adjustment. We may have just readjusted TYPE because
7294          the variable specified more dimensions. Make sure we have
7295          a reference if we can and don't have one already. */
7296       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7297
7298       real_type = GET_REAL_TYPE (type);
7299       /* Never layout this decl. This will be done when its scope
7300          will be entered */
7301       decl = build_decl (VAR_DECL, name, real_type);
7302       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7303       DECL_FINAL (decl) = final_p;
7304       BLOCK_CHAIN_DECL (decl);
7305
7306       /* If doing xreferencing, replace the line number with the WFL
7307          compound value */
7308       if (flag_emit_xref)
7309         DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7310
7311       /* Don't try to use an INIT statement when an error was found */
7312       if (init && java_error_count)
7313         init = NULL_TREE;
7314
7315       /* Add the initialization function to the current function's code */
7316       if (init)
7317         {
7318           /* Name might have been readjusted */
7319           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7320           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7321           java_method_add_stmt (current_function_decl,
7322                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7323                                                       init));
7324         }
7325
7326       /* Setup dependency the type of the decl */
7327       if (must_chain)
7328         {
7329           jdep *dep;
7330           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7331           dep = CLASSD_LAST (ctxp->classd_list);
7332           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7333         }
7334     }
7335   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7336 }
7337
7338 /* Called during parsing. Build decls from argument list.  */
7339
7340 static void
7341 source_start_java_method (tree fndecl)
7342 {
7343   tree tem;
7344   tree parm_decl;
7345   int i;
7346
7347   if (!fndecl)
7348     return;
7349
7350   current_function_decl = fndecl;
7351
7352   /* New scope for the function */
7353   enter_block ();
7354   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7355        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7356     {
7357       tree type = TREE_VALUE (tem);
7358       tree name = TREE_PURPOSE (tem);
7359
7360       /* If type is incomplete. Create an incomplete decl and ask for
7361          the decl to be patched later */
7362       if (INCOMPLETE_TYPE_P (type))
7363         {
7364           jdep *jdep;
7365           tree real_type = GET_REAL_TYPE (type);
7366           parm_decl = build_decl (PARM_DECL, name, real_type);
7367           type = obtain_incomplete_type (type);
7368           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7369           jdep = CLASSD_LAST (ctxp->classd_list);
7370           JDEP_MISC (jdep) = name;
7371           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7372         }
7373       else
7374         parm_decl = build_decl (PARM_DECL, name, type);
7375
7376       /* Remember if a local variable was declared final (via its
7377          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7378       if (ARG_FINAL_P (tem))
7379         {
7380           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7381           DECL_FINAL (parm_decl) = 1;
7382         }
7383
7384       BLOCK_CHAIN_DECL (parm_decl);
7385     }
7386   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7387   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7388     nreverse (tem);
7389   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7390   DECL_MAX_LOCALS (current_function_decl) = i;
7391 }
7392
7393 /* Called during parsing. Creates an artificial method declaration.  */
7394
7395 static tree
7396 create_artificial_method (tree class, int flags, tree type,
7397                           tree name, tree args)
7398 {
7399   tree mdecl;
7400
7401   java_parser_context_save_global ();
7402   input_line = 0;
7403   mdecl = make_node (FUNCTION_TYPE);
7404   TREE_TYPE (mdecl) = type;
7405   TYPE_ARG_TYPES (mdecl) = args;
7406   mdecl = add_method (class, flags, name, build_java_signature (mdecl));
7407   java_parser_context_restore_global ();
7408   DECL_ARTIFICIAL (mdecl) = 1;
7409   return mdecl;
7410 }
7411
7412 /* Starts the body if an artificial method.  */
7413
7414 static void
7415 start_artificial_method_body (tree mdecl)
7416 {
7417   DECL_SOURCE_LINE (mdecl) = 1;
7418   DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7419   source_start_java_method (mdecl);
7420   enter_block ();
7421 }
7422
7423 static void
7424 end_artificial_method_body (tree mdecl)
7425 {
7426   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7427      It has to be evaluated first. (if mdecl is current_function_decl,
7428      we have an undefined behavior if no temporary variable is used.) */
7429   tree b = exit_block ();
7430   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7431   exit_block ();
7432 }
7433
7434 /* Dump a tree of some kind.  This is a convenience wrapper for the
7435    dump_* functions in tree-dump.c.  */
7436 static void
7437 dump_java_tree (enum tree_dump_index phase, tree t)
7438 {
7439   FILE *stream;
7440   int flags;
7441
7442   stream = dump_begin (phase, &flags);
7443   flags |= TDF_SLIM;
7444   if (stream)
7445     {
7446       dump_node (t, flags, stream);
7447       dump_end (phase, stream);
7448     }
7449 }
7450
7451 /* Terminate a function and expand its body.  */
7452
7453 static void
7454 source_end_java_method (void)
7455 {
7456   tree fndecl = current_function_decl;
7457
7458   if (!fndecl)
7459     return;
7460
7461   java_parser_context_save_global ();
7462   input_line = ctxp->last_ccb_indent1;
7463
7464   /* Turn function bodies with only a NOP expr null, so they don't get
7465      generated at all and we won't get warnings when using the -W
7466      -Wall flags. */
7467   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
7468     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7469
7470   /* We've generated all the trees for this function, and it has been
7471      patched.  Dump it to a file if the user requested it.  */
7472   dump_java_tree (TDI_original, fndecl);
7473
7474   /* In unit-at-a-time mode, don't expand the method yet.  */
7475   if (DECL_SAVED_TREE (fndecl) && flag_unit_at_a_time)
7476     {
7477       cgraph_finalize_function (fndecl);
7478       current_function_decl = NULL_TREE;
7479       java_parser_context_restore_global ();
7480       return;
7481     }
7482
7483   java_optimize_inline (fndecl);
7484
7485   /* Expand the function's body.  */
7486   java_expand_body (fndecl);
7487
7488   java_parser_context_restore_global ();
7489 }
7490
7491 /* Record EXPR in the current function block. Complements compound
7492    expression second operand if necessary.  */
7493
7494 tree
7495 java_method_add_stmt (tree fndecl, tree expr)
7496 {
7497   if (!GET_CURRENT_BLOCK (fndecl))
7498     return NULL_TREE;
7499   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7500 }
7501
7502 static tree
7503 add_stmt_to_block (tree b, tree type, tree stmt)
7504 {
7505   tree body = BLOCK_EXPR_BODY (b), c;
7506
7507   if (java_error_count)
7508     return body;
7509
7510   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7511     return body;
7512
7513   BLOCK_EXPR_BODY (b) = c;
7514   TREE_SIDE_EFFECTS (c) = 1;
7515   return c;
7516 }
7517
7518 /* Add STMT to EXISTING if possible, otherwise create a new
7519    COMPOUND_EXPR and add STMT to it. */
7520
7521 static tree
7522 add_stmt_to_compound (tree existing, tree type, tree stmt)
7523 {
7524   if (existing)
7525     return build (COMPOUND_EXPR, type, existing, stmt);
7526   else
7527     return stmt;
7528 }
7529
7530 void java_layout_seen_class_methods (void)
7531 {
7532   tree previous_list = all_class_list;
7533   tree end = NULL_TREE;
7534   tree current;
7535
7536   while (1)
7537     {
7538       for (current = previous_list;
7539            current != end; current = TREE_CHAIN (current))
7540         layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
7541
7542       if (previous_list != all_class_list)
7543         {
7544           end = previous_list;
7545           previous_list = all_class_list;
7546         }
7547       else
7548         break;
7549     }
7550 }
7551
7552 static GTY(()) tree stop_reordering;
7553 void
7554 java_reorder_fields (void)
7555 {
7556   tree current;
7557
7558   for (current = gclass_list; current; current = TREE_CHAIN (current))
7559     {
7560       current_class = TREE_TYPE (TREE_VALUE (current));
7561
7562       if (current_class == stop_reordering)
7563         break;
7564
7565       /* Reverse the fields, but leave the dummy field in front.
7566          Fields are already ordered for Object and Class */
7567       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7568           && current_class != class_type_node)
7569       {
7570         /* If the dummy field is there, reverse the right fields and
7571            just layout the type for proper fields offset */
7572         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7573           {
7574             tree fields = TYPE_FIELDS (current_class);
7575             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7576             TYPE_SIZE (current_class) = NULL_TREE;
7577           }
7578         /* We don't have a dummy field, we need to layout the class,
7579            after having reversed the fields */
7580         else
7581           {
7582             TYPE_FIELDS (current_class) =
7583               nreverse (TYPE_FIELDS (current_class));
7584             TYPE_SIZE (current_class) = NULL_TREE;
7585           }
7586       }
7587     }
7588   /* There are cases were gclass_list will be empty. */
7589   if (gclass_list)
7590     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7591 }
7592
7593 /* Layout the methods of all classes loaded in one way or another.
7594    Check methods of source parsed classes. Then reorder the
7595    fields and layout the classes or the type of all source parsed
7596    classes */
7597
7598 void
7599 java_layout_classes (void)
7600 {
7601   tree current;
7602   int save_error_count = java_error_count;
7603
7604   /* Layout the methods of all classes seen so far */
7605   java_layout_seen_class_methods ();
7606   java_parse_abort_on_error ();
7607   all_class_list = NULL_TREE;
7608
7609   /* Then check the methods of all parsed classes */
7610   for (current = gclass_list; current; current = TREE_CHAIN (current))
7611     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7612       java_check_methods (TREE_VALUE (current));
7613   java_parse_abort_on_error ();
7614
7615   for (current = gclass_list; current; current = TREE_CHAIN (current))
7616     {
7617       current_class = TREE_TYPE (TREE_VALUE (current));
7618       layout_class (current_class);
7619
7620       /* Error reported by the caller */
7621       if (java_error_count)
7622         return;
7623     }
7624
7625   /* We might have reloaded classes durign the process of laying out
7626      classes for code generation. We must layout the methods of those
7627      late additions, as constructor checks might use them */
7628   java_layout_seen_class_methods ();
7629   java_parse_abort_on_error ();
7630 }
7631
7632 /* Expand methods in the current set of classes rememebered for
7633    generation.  */
7634
7635 static void
7636 java_complete_expand_classes (void)
7637 {
7638   tree current;
7639
7640   do_not_fold = flag_emit_xref;
7641
7642   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7643     if (!INNER_CLASS_DECL_P (current))
7644       java_complete_expand_class (current);
7645 }
7646
7647 /* Expand the methods found in OUTER, starting first by OUTER's inner
7648    classes, if any.  */
7649
7650 static void
7651 java_complete_expand_class (tree outer)
7652 {
7653   tree inner_list;
7654
7655   set_nested_class_simple_name_value (outer, 1); /* Set */
7656
7657   /* We need to go after all inner classes and start expanding them,
7658      starting with most nested ones. We have to do that because nested
7659      classes might add functions to outer classes */
7660
7661   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7662        inner_list; inner_list = TREE_CHAIN (inner_list))
7663     java_complete_expand_class (TREE_PURPOSE (inner_list));
7664
7665   java_complete_expand_methods (outer);
7666   set_nested_class_simple_name_value (outer, 0); /* Reset */
7667 }
7668
7669 /* Expand methods registered in CLASS_DECL. The general idea is that
7670    we expand regular methods first. This allows us get an estimate on
7671    how outer context local alias fields are really used so we can add
7672    to the constructor just enough code to initialize them properly (it
7673    also lets us generate finit$ correctly.) Then we expand the
7674    constructors and then <clinit>.  */
7675
7676 static void
7677 java_complete_expand_methods (tree class_decl)
7678 {
7679   tree clinit, decl, first_decl;
7680
7681   current_class = TREE_TYPE (class_decl);
7682
7683   /* Initialize a new constant pool */
7684   init_outgoing_cpool ();
7685
7686   /* Pre-expand <clinit> to figure whether we really need it or
7687      not. If we do need it, we pre-expand the static fields so they're
7688      ready to be used somewhere else. <clinit> will be fully expanded
7689      after we processed the constructors. */
7690   first_decl = TYPE_METHODS (current_class);
7691   clinit = maybe_generate_pre_expand_clinit (current_class);
7692
7693   /* Then generate finit$ (if we need to) because constructors will
7694    try to use it.*/
7695   if (TYPE_FINIT_STMT_LIST (current_class))
7696     java_complete_expand_method (generate_finit (current_class));
7697
7698   /* Then generate instinit$ (if we need to) because constructors will
7699      try to use it. */
7700   if (TYPE_II_STMT_LIST (current_class))
7701     java_complete_expand_method (generate_instinit (current_class));
7702
7703   /* Now do the constructors */
7704   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7705     {
7706       int no_body;
7707
7708       if (!DECL_CONSTRUCTOR_P (decl))
7709         continue;
7710
7711       no_body = !DECL_FUNCTION_BODY (decl);
7712       /* Don't generate debug info on line zero when expanding a
7713          generated constructor. */
7714       if (no_body)
7715         restore_line_number_status (1);
7716
7717       java_complete_expand_method (decl);
7718
7719       if (no_body)
7720         restore_line_number_status (0);
7721     }
7722
7723   /* First, do the ordinary methods. */
7724   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7725     {
7726       /* Ctors aren't part of this batch. */
7727       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7728         continue;
7729
7730       /* Skip abstract or native methods -- but do handle native
7731          methods when generating JNI stubs.  */
7732       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7733         {
7734           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7735           continue;
7736         }
7737
7738       if (METHOD_NATIVE (decl))
7739         {
7740           tree body;
7741           current_function_decl = decl;
7742           body = build_jni_stub (decl);
7743           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7744         }
7745
7746       java_complete_expand_method (decl);
7747     }
7748
7749   /* If there is indeed a <clinit>, fully expand it now */
7750   if (clinit)
7751     {
7752       /* Prevent the use of `this' inside <clinit> */
7753       ctxp->explicit_constructor_p = 1;
7754       java_complete_expand_method (clinit);
7755       ctxp->explicit_constructor_p = 0;
7756     }
7757
7758   /* We might have generated a class$ that we now want to expand */
7759   if (TYPE_DOT_CLASS (current_class))
7760     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7761
7762   /* Now verify constructor circularity (stop after the first one we
7763      prove wrong.) */
7764   if (!CLASS_INTERFACE (class_decl))
7765     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7766       if (DECL_CONSTRUCTOR_P (decl)
7767           && verify_constructor_circularity (decl, decl))
7768         break;
7769
7770   /* Save the constant pool. We'll need to restore it later. */
7771   TYPE_CPOOL (current_class) = outgoing_cpool;
7772 }
7773
7774 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7775    safely used in some other methods/constructors.  */
7776
7777 static tree
7778 maybe_generate_pre_expand_clinit (tree class_type)
7779 {
7780   tree current, mdecl;
7781
7782   if (!TYPE_CLINIT_STMT_LIST (class_type))
7783     return NULL_TREE;
7784
7785   /* Go through all static fields and pre expand them */
7786   for (current = TYPE_FIELDS (class_type); current;
7787        current = TREE_CHAIN (current))
7788     if (FIELD_STATIC (current))
7789       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7790
7791   /* Then build the <clinit> method */
7792   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7793                                     clinit_identifier_node, end_params_node);
7794   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7795                        mdecl, NULL_TREE);
7796   start_artificial_method_body (mdecl);
7797
7798   /* We process the list of assignment we produced as the result of
7799      the declaration of initialized static field and add them as
7800      statement to the <clinit> method. */
7801   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7802        current = TREE_CHAIN (current))
7803     {
7804       tree stmt = current;
7805       /* We build the assignment expression that will initialize the
7806          field to its value. There are strict rules on static
7807          initializers (8.5). FIXME */
7808       if (TREE_CODE (stmt) != BLOCK && stmt != empty_stmt_node)
7809         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7810       java_method_add_stmt (mdecl, stmt);
7811     }
7812
7813   end_artificial_method_body (mdecl);
7814
7815   /* Now we want to place <clinit> as the last method (because we need
7816      it at least for interface so that it doesn't interfere with the
7817      dispatch table based lookup. */
7818   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7819     {
7820       current = TREE_CHAIN (TYPE_METHODS (class_type));
7821       TYPE_METHODS (class_type) = current;
7822
7823       while (TREE_CHAIN (current))
7824         current = TREE_CHAIN (current);
7825
7826       TREE_CHAIN (current) = mdecl;
7827       TREE_CHAIN (mdecl) = NULL_TREE;
7828     }
7829
7830   return mdecl;
7831 }
7832
7833 /* Analyzes a method body and look for something that isn't a
7834    MODIFY_EXPR with a constant value.  */
7835
7836 static int
7837 analyze_clinit_body (tree this_class, tree bbody)
7838 {
7839   while (bbody)
7840     switch (TREE_CODE (bbody))
7841       {
7842       case BLOCK:
7843         bbody = BLOCK_EXPR_BODY (bbody);
7844         break;
7845
7846       case EXPR_WITH_FILE_LOCATION:
7847         bbody = EXPR_WFL_NODE (bbody);
7848         break;
7849
7850       case COMPOUND_EXPR:
7851         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
7852           return 1;
7853         bbody = TREE_OPERAND (bbody, 1);
7854         break;
7855
7856       case MODIFY_EXPR:
7857         /* If we're generating to class file and we're dealing with an
7858            array initialization, we return 1 to keep <clinit> */
7859         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
7860             && flag_emit_class_files)
7861           return 1;
7862
7863         /* There are a few cases where we're required to keep
7864            <clinit>:
7865            - If this is an assignment whose operand is not constant,
7866            - If this is an assignment to a non-initialized field,
7867            - If this field is not a member of the current class.
7868         */
7869         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
7870                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
7871                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
7872
7873       default:
7874         return 1;
7875       }
7876   return 0;
7877 }
7878
7879
7880 /* See whether we could get rid of <clinit>. Criteria are: all static
7881    final fields have constant initial values and the body of <clinit>
7882    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7883
7884 static int
7885 maybe_yank_clinit (tree mdecl)
7886 {
7887   tree type, current;
7888   tree fbody, bbody;
7889
7890   if (!DECL_CLINIT_P (mdecl))
7891     return 0;
7892
7893   /* If the body isn't empty, then we keep <clinit>. Note that if
7894      we're emitting classfiles, this isn't enough not to rule it
7895      out. */
7896   fbody = DECL_FUNCTION_BODY (mdecl);
7897   bbody = BLOCK_EXPR_BODY (fbody);
7898   if (bbody && bbody != error_mark_node)
7899     bbody = BLOCK_EXPR_BODY (bbody);
7900   else
7901     return 0;
7902   if (bbody && ! flag_emit_class_files && bbody != empty_stmt_node)
7903     return 0;
7904
7905   type = DECL_CONTEXT (mdecl);
7906   current = TYPE_FIELDS (type);
7907
7908   for (current = (current ? TREE_CHAIN (current) : current);
7909        current; current = TREE_CHAIN (current))
7910     {
7911       tree f_init;
7912
7913       /* We're not interested in non-static fields.  */
7914       if (!FIELD_STATIC (current))
7915         continue;
7916
7917       /* Nor in fields without initializers. */
7918       f_init = DECL_INITIAL (current);
7919       if (f_init == NULL_TREE)
7920         continue;
7921
7922       /* Anything that isn't String or a basic type is ruled out -- or
7923          if we know how to deal with it (when doing things natively) we
7924          should generated an empty <clinit> so that SUID are computed
7925          correctly. */
7926       if (! JSTRING_TYPE_P (TREE_TYPE (current))
7927           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
7928         return 0;
7929
7930       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
7931         return 0;
7932     }
7933
7934   /* Now we analyze the method body and look for something that
7935      isn't a MODIFY_EXPR */
7936   if (bbody != empty_stmt_node && analyze_clinit_body (type, bbody))
7937     return 0;
7938
7939   /* Get rid of <clinit> in the class' list of methods */
7940   if (TYPE_METHODS (type) == mdecl)
7941     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7942   else
7943     for (current = TYPE_METHODS (type); current;
7944          current = TREE_CHAIN (current))
7945       if (TREE_CHAIN (current) == mdecl)
7946         {
7947           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7948           break;
7949         }
7950
7951   return 1;
7952 }
7953
7954 /* Install the argument from MDECL. Suitable to completion and
7955    expansion of mdecl's body.  */
7956
7957 void
7958 start_complete_expand_method (tree mdecl)
7959 {
7960   tree tem;
7961
7962   pushlevel (1);                /* Prepare for a parameter push */
7963   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7964   DECL_ARGUMENTS (mdecl) = tem;
7965
7966   for (; tem; tem = TREE_CHAIN (tem))
7967     {
7968       /* TREE_CHAIN (tem) will change after pushdecl. */
7969       tree next = TREE_CHAIN (tem);
7970       tree type = TREE_TYPE (tem);
7971       if (PROMOTE_PROTOTYPES
7972           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
7973           && INTEGRAL_TYPE_P (type))
7974         type = integer_type_node;
7975       DECL_ARG_TYPE (tem) = type;
7976       layout_decl (tem, 0);
7977       pushdecl (tem);
7978       /* Re-install the next so that the list is kept and the loop
7979          advances. */
7980       TREE_CHAIN (tem) = next;
7981     }
7982   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
7983   input_line = DECL_SOURCE_LINE (mdecl);
7984   build_result_decl (mdecl);
7985 }
7986
7987
7988 /* Complete and expand a method.  */
7989
7990 static void
7991 java_complete_expand_method (tree mdecl)
7992 {
7993   tree fbody, block_body, exception_copy;
7994
7995   current_function_decl = mdecl;
7996   /* Fix constructors before expanding them */
7997   if (DECL_CONSTRUCTOR_P (mdecl))
7998     fix_constructors (mdecl);
7999
8000   /* Expand functions that have a body */
8001   if (!DECL_FUNCTION_BODY (mdecl))
8002     return;
8003
8004   fbody = DECL_FUNCTION_BODY (mdecl);
8005   block_body = BLOCK_EXPR_BODY (fbody);
8006   exception_copy = NULL_TREE;
8007
8008   current_function_decl = mdecl;
8009
8010   if (! quiet_flag)
8011     fprintf (stderr, " [%s.",
8012              lang_printable_name (DECL_CONTEXT (mdecl), 0));
8013   announce_function (mdecl);
8014   if (! quiet_flag)
8015     fprintf (stderr, "]");
8016
8017   /* Prepare the function for tree completion */
8018   start_complete_expand_method (mdecl);
8019
8020   /* Install the current this */
8021   current_this = (!METHOD_STATIC (mdecl) ?
8022                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8023
8024   /* Purge the `throws' list of unchecked exceptions (we save a copy
8025      of the list and re-install it later.) */
8026   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8027   purge_unchecked_exceptions (mdecl);
8028
8029   /* Install exceptions thrown with `throws' */
8030   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8031
8032   if (block_body != NULL_TREE)
8033     {
8034       block_body = java_complete_tree (block_body);
8035
8036       /* Before we check initialization, attached all class initialization
8037          variable to the block_body */
8038       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8039                      attach_init_test_initialization_flags, block_body);
8040
8041       if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
8042         {
8043           check_for_initialization (block_body, mdecl);
8044
8045           /* Go through all the flags marking the initialization of
8046              static variables and see whether they're definitively
8047              assigned, in which case the type is remembered as
8048              definitively initialized in MDECL. */
8049           if (STATIC_CLASS_INIT_OPT_P ())
8050             {
8051               /* Always register the context as properly initialized in
8052                  MDECL. This used with caution helps removing extra
8053                  initialization of self. */
8054               if (METHOD_STATIC (mdecl))
8055                 {
8056                   *(htab_find_slot
8057                     (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8058                      DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8059                 }
8060             }
8061         }
8062       ctxp->explicit_constructor_p = 0;
8063     }
8064
8065   BLOCK_EXPR_BODY (fbody) = block_body;
8066
8067   /* If we saw a return but couldn't evaluate it properly, we'll have
8068      an error_mark_node here. */
8069   if (block_body != error_mark_node
8070       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8071       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
8072       && !flag_emit_xref)
8073     missing_return_error (current_function_decl);
8074
8075   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8076   maybe_yank_clinit (mdecl);
8077
8078   /* Pop the current level, with special measures if we found errors. */
8079   if (java_error_count)
8080     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8081   poplevel (1, 0, 1);
8082
8083   /* Pop the exceptions and sanity check */
8084   POP_EXCEPTIONS();
8085   if (currently_caught_type_list)
8086     abort ();
8087
8088   /* Restore the copy of the list of exceptions if emitting xrefs. */
8089   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8090 }
8091
8092 /* For with each class for which there's code to generate. */
8093
8094 static void
8095 java_expand_method_bodies (tree class)
8096 {
8097   tree decl;
8098   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8099     {
8100       tree block;
8101       tree body;
8102
8103       if (! DECL_FUNCTION_BODY (decl))
8104         continue;
8105
8106       current_function_decl = decl;
8107
8108       block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8109
8110       if (TREE_CODE (block) != BLOCK)
8111         abort ();
8112
8113       /* Save the function body for inlining.  */
8114       DECL_SAVED_TREE (decl) = block;
8115
8116       body = BLOCK_EXPR_BODY (block);
8117
8118       if (TREE_TYPE (body) == NULL_TREE)
8119         abort ();
8120
8121       /* It's time to assign the variable flagging static class
8122          initialization based on which classes invoked static methods
8123          are definitely initializing. This should be flagged. */
8124       if (STATIC_CLASS_INIT_OPT_P ())
8125         {
8126           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8127           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8128             {
8129               /* Executed for each statement calling a static function.
8130                  LIST is a TREE_LIST whose PURPOSE is the called function
8131                  and VALUE is a compound whose second operand can be patched
8132                  with static class initialization flag assignments.  */
8133
8134               tree called_method = TREE_PURPOSE (list);
8135               tree compound = TREE_VALUE (list);
8136               tree assignment_compound_list
8137                 = build_tree_list (called_method, NULL);
8138
8139               /* For each class definitely initialized in
8140                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8141                  assignment to the class initialization flag. */
8142               htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8143                              emit_test_initialization,
8144                              assignment_compound_list);
8145
8146               if (TREE_VALUE (assignment_compound_list))
8147                 TREE_OPERAND (compound, 1)
8148                   = TREE_VALUE (assignment_compound_list);
8149             }
8150         }
8151
8152       /* Prepend class initialization to static methods.  */
8153       if (METHOD_STATIC (decl) && ! METHOD_PRIVATE (decl)
8154           && ! flag_emit_class_files
8155           && ! DECL_CLINIT_P (decl)
8156           && ! CLASS_INTERFACE (TYPE_NAME (class)))
8157         {
8158           tree init = build (CALL_EXPR, void_type_node,
8159                              build_address_of (soft_initclass_node),
8160                              build_tree_list (NULL_TREE,
8161                                               build_class_ref (class)),
8162                              NULL_TREE);
8163           TREE_SIDE_EFFECTS (init) = 1;
8164           body = build (COMPOUND_EXPR, TREE_TYPE (body), init, body);
8165           BLOCK_EXPR_BODY (block) = body;
8166         }
8167
8168       /* Wrap synchronized method bodies in a monitorenter
8169          plus monitorexit cleanup.  */
8170       if (METHOD_SYNCHRONIZED (decl) && ! flag_emit_class_files)
8171         {
8172           tree enter, exit, lock;
8173           if (METHOD_STATIC (decl))
8174             lock = build_class_ref (class);
8175           else
8176             lock = DECL_ARGUMENTS (decl);
8177           BUILD_MONITOR_ENTER (enter, lock);
8178           BUILD_MONITOR_EXIT (exit, lock);
8179
8180           body = build (COMPOUND_EXPR, void_type_node,
8181                         enter,
8182                         build (TRY_FINALLY_EXPR, void_type_node, body, exit));
8183           BLOCK_EXPR_BODY (block) = body;
8184         }
8185
8186       /* Expand the the function body.  */
8187       source_end_java_method ();
8188     }
8189 }
8190
8191 \f
8192
8193 /* This section of the code deals with accessing enclosing context
8194    fields either directly by using the relevant access to this$<n> or
8195    by invoking an access method crafted for that purpose.  */
8196
8197 /* Build the necessary access from an inner class to an outer
8198    class. This routine could be optimized to cache previous result
8199    (decl, current_class and returned access).  When an access method
8200    needs to be generated, it always takes the form of a read. It might
8201    be later turned into a write by calling outer_field_access_fix.  */
8202
8203 static tree
8204 build_outer_field_access (tree id, tree decl)
8205 {
8206   tree access = NULL_TREE;
8207   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8208   tree decl_ctx = DECL_CONTEXT (decl);
8209
8210   /* If the immediate enclosing context of the current class is the
8211      field decl's class or inherits from it; build the access as
8212      `this$<n>.<field>'. Note that we will break the `private' barrier
8213      if we're not emitting bytecodes. */
8214   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8215       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8216     {
8217       tree thisn = build_current_thisn (current_class);
8218       access = make_qualified_primary (build_wfl_node (thisn),
8219                                        id, EXPR_WFL_LINECOL (id));
8220     }
8221   /* Otherwise, generate access methods to outer this and access the
8222      field (either using an access method or by direct access.) */
8223   else
8224     {
8225       int lc = EXPR_WFL_LINECOL (id);
8226
8227       /* Now we chain the required number of calls to the access$0 to
8228          get a hold to the enclosing instance we need, and then we
8229          build the field access. */
8230       access = build_access_to_thisn (current_class, decl_ctx, lc);
8231
8232       /* If the field is private and we're generating bytecode, then
8233          we generate an access method */
8234       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8235         {
8236           tree name = build_outer_field_access_methods (decl);
8237           access = build_outer_field_access_expr (lc, decl_ctx,
8238                                                   name, access, NULL_TREE);
8239         }
8240       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8241          Once again we break the `private' access rule from a foreign
8242          class. */
8243       else
8244         access = make_qualified_primary (access, id, lc);
8245     }
8246   return resolve_expression_name (access, NULL);
8247 }
8248
8249 /* Return a nonzero value if NODE describes an outer field inner
8250    access.  */
8251
8252 static int
8253 outer_field_access_p (tree type, tree decl)
8254 {
8255   if (!INNER_CLASS_TYPE_P (type)
8256       || TREE_CODE (decl) != FIELD_DECL
8257       || DECL_CONTEXT (decl) == type)
8258     return 0;
8259
8260   /* If the inner class extends the declaration context of the field
8261      we're try to acces, then this isn't an outer field access */
8262   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8263     return 0;
8264
8265   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8266        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8267     {
8268       if (type == DECL_CONTEXT (decl))
8269         return 1;
8270
8271       if (!DECL_CONTEXT (TYPE_NAME (type)))
8272         {
8273           /* Before we give up, see whether the field is inherited from
8274              the enclosing context we're considering. */
8275           if (inherits_from_p (type, DECL_CONTEXT (decl)))
8276             return 1;
8277           break;
8278         }
8279     }
8280
8281   return 0;
8282 }
8283
8284 /* Return a nonzero value if NODE represents an outer field inner
8285    access that was been already expanded. As a side effect, it returns
8286    the name of the field being accessed and the argument passed to the
8287    access function, suitable for a regeneration of the access method
8288    call if necessary. */
8289
8290 static int
8291 outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8292                                tree *arg)
8293 {
8294   int identified = 0;
8295
8296   if (TREE_CODE (node) != CALL_EXPR)
8297     return 0;
8298
8299   /* Well, gcj generates slightly different tree nodes when compiling
8300      to native or bytecodes. It's the case for function calls. */
8301
8302   if (flag_emit_class_files
8303       && TREE_CODE (node) == CALL_EXPR
8304       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8305     identified = 1;
8306   else if (!flag_emit_class_files)
8307     {
8308       node = TREE_OPERAND (node, 0);
8309
8310       if (node && TREE_OPERAND (node, 0)
8311           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8312         {
8313           node = TREE_OPERAND (node, 0);
8314           if (TREE_OPERAND (node, 0)
8315               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8316               && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8317                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8318             identified = 1;
8319         }
8320     }
8321
8322   if (identified && name && arg_type && arg)
8323     {
8324       tree argument = TREE_OPERAND (node, 1);
8325       *name = DECL_NAME (TREE_OPERAND (node, 0));
8326       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8327       *arg = TREE_VALUE (argument);
8328     }
8329   return identified;
8330 }
8331
8332 /* Detect in NODE an outer field read access from an inner class and
8333    transform it into a write with RHS as an argument. This function is
8334    called from the java_complete_lhs when an assignment to a LHS can
8335    be identified. */
8336
8337 static tree
8338 outer_field_access_fix (tree wfl, tree node, tree rhs)
8339 {
8340   tree name, arg_type, arg;
8341
8342   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8343     {
8344       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8345                                             arg_type, name, arg, rhs);
8346       return java_complete_tree (node);
8347     }
8348   return NULL_TREE;
8349 }
8350
8351 /* Construct the expression that calls an access method:
8352      <type>.access$<n>(<arg1> [, <arg2>]);
8353
8354    ARG2 can be NULL and will be omitted in that case. It will denote a
8355    read access.  */
8356
8357 static tree
8358 build_outer_field_access_expr (int lc, tree type, tree access_method_name,
8359                                tree arg1, tree arg2)
8360 {
8361   tree args, cn, access;
8362
8363   args = arg1 ? arg1 :
8364     build_wfl_node (build_current_thisn (current_class));
8365   args = build_tree_list (NULL_TREE, args);
8366
8367   if (arg2)
8368     args = tree_cons (NULL_TREE, arg2, args);
8369
8370   access = build_method_invocation (build_wfl_node (access_method_name), args);
8371   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8372   return make_qualified_primary (cn, access, lc);
8373 }
8374
8375 static tree
8376 build_new_access_id (void)
8377 {
8378   static int access_n_counter = 1;
8379   char buffer [128];
8380
8381   sprintf (buffer, "access$%d", access_n_counter++);
8382   return get_identifier (buffer);
8383 }
8384
8385 /* Create the static access functions for the outer field DECL. We define a
8386    read:
8387      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8388        return inst$.field;
8389      }
8390    and a write access:
8391      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8392                                      TREE_TYPE (<field>) value$) {
8393        return inst$.field = value$;
8394      }
8395    We should have a usage flags on the DECL so we can lazily turn the ones
8396    we're using for code generation. FIXME.
8397 */
8398
8399 static tree
8400 build_outer_field_access_methods (tree decl)
8401 {
8402   tree id, args, stmt, mdecl;
8403
8404   if (FIELD_INNER_ACCESS_P (decl))
8405     return FIELD_INNER_ACCESS (decl);
8406
8407   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8408
8409   /* Create the identifier and a function named after it. */
8410   id = build_new_access_id ();
8411
8412   /* The identifier is marked as bearing the name of a generated write
8413      access function for outer field accessed from inner classes. */
8414   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8415
8416   /* Create the read access */
8417   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8418   TREE_CHAIN (args) = end_params_node;
8419   stmt = make_qualified_primary (build_wfl_node (inst_id),
8420                                  build_wfl_node (DECL_NAME (decl)), 0);
8421   stmt = build_return (0, stmt);
8422   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8423                                            TREE_TYPE (decl), id, args, stmt);
8424   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8425
8426   /* Create the write access method. No write access for final variable */
8427   if (!FIELD_FINAL (decl))
8428     {
8429       args = build_tree_list (inst_id,
8430                               build_pointer_type (DECL_CONTEXT (decl)));
8431       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8432       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8433       stmt = make_qualified_primary (build_wfl_node (inst_id),
8434                                      build_wfl_node (DECL_NAME (decl)), 0);
8435       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8436                                                 build_wfl_node (wpv_id)));
8437       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8438                                                TREE_TYPE (decl), id,
8439                                                args, stmt);
8440     }
8441   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8442
8443   /* Return the access name */
8444   return FIELD_INNER_ACCESS (decl) = id;
8445 }
8446
8447 /* Build an field access method NAME.  */
8448
8449 static tree
8450 build_outer_field_access_method (tree class, tree type, tree name,
8451                                  tree args, tree body)
8452 {
8453   tree saved_current_function_decl, mdecl;
8454
8455   /* Create the method */
8456   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8457   fix_method_argument_names (args, mdecl);
8458   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8459
8460   /* Attach the method body. */
8461   saved_current_function_decl = current_function_decl;
8462   start_artificial_method_body (mdecl);
8463   java_method_add_stmt (mdecl, body);
8464   end_artificial_method_body (mdecl);
8465   current_function_decl = saved_current_function_decl;
8466
8467   return mdecl;
8468 }
8469
8470 \f
8471 /* This section deals with building access function necessary for
8472    certain kinds of method invocation from inner classes.  */
8473
8474 static tree
8475 build_outer_method_access_method (tree decl)
8476 {
8477   tree saved_current_function_decl, mdecl;
8478   tree args = NULL_TREE, call_args = NULL_TREE;
8479   tree carg, id, body, class;
8480   char buffer [80];
8481   int parm_id_count = 0;
8482
8483   /* Test this abort with an access to a private field */
8484   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8485     abort ();
8486
8487   /* Check the cache first */
8488   if (DECL_FUNCTION_INNER_ACCESS (decl))
8489     return DECL_FUNCTION_INNER_ACCESS (decl);
8490
8491   class = DECL_CONTEXT (decl);
8492
8493   /* Obtain an access identifier and mark it */
8494   id = build_new_access_id ();
8495   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8496
8497   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8498   /* Create the arguments, as much as the original */
8499   for (; carg && carg != end_params_node;
8500        carg = TREE_CHAIN (carg))
8501     {
8502       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8503       args = chainon (args, build_tree_list (get_identifier (buffer),
8504                                              TREE_VALUE (carg)));
8505     }
8506   args = chainon (args, end_params_node);
8507
8508   /* Create the method */
8509   mdecl = create_artificial_method (class, ACC_STATIC,
8510                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8511   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8512   /* There is a potential bug here. We should be able to use
8513      fix_method_argument_names, but then arg names get mixed up and
8514      eventually a constructor will have its this$0 altered and the
8515      outer context won't be assignment properly. The test case is
8516      stub.java FIXME */
8517   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8518
8519   /* Attach the method body. */
8520   saved_current_function_decl = current_function_decl;
8521   start_artificial_method_body (mdecl);
8522
8523   /* The actual method invocation uses the same args. When invoking a
8524      static methods that way, we don't want to skip the first
8525      argument. */
8526   carg = args;
8527   if (!METHOD_STATIC (decl))
8528     carg = TREE_CHAIN (carg);
8529   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8530     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8531                            call_args);
8532
8533   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8534                                   call_args);
8535   if (!METHOD_STATIC (decl))
8536     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8537                                    body, 0);
8538   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8539     body = build_return (0, body);
8540   java_method_add_stmt (mdecl,body);
8541   end_artificial_method_body (mdecl);
8542   current_function_decl = saved_current_function_decl;
8543
8544   /* Back tag the access function so it know what it accesses */
8545   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8546
8547   /* Tag the current method so it knows it has an access generated */
8548   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8549 }
8550
8551 \f
8552 /* This section of the code deals with building expressions to access
8553    the enclosing instance of an inner class. The enclosing instance is
8554    kept in a generated field called this$<n>, with <n> being the
8555    inner class nesting level (starting from 0.)  */
8556
8557 /* Build an access to a given this$<n>, always chaining access call to
8558    others. Access methods to this$<n> are build on the fly if
8559    necessary. This CAN'T be used to solely access this$<n-1> from
8560    this$<n> (which alway yield to special cases and optimization, see
8561    for example build_outer_field_access).  */
8562
8563 static tree
8564 build_access_to_thisn (tree from, tree to, int lc)
8565 {
8566   tree access = NULL_TREE;
8567
8568   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8569     {
8570       if (!access)
8571         {
8572           access = build_current_thisn (from);
8573           access = build_wfl_node (access);
8574         }
8575       else
8576         {
8577           tree access0_wfl, cn;
8578
8579           maybe_build_thisn_access_method (from);
8580           access0_wfl = build_wfl_node (access0_identifier_node);
8581           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8582           EXPR_WFL_LINECOL (access0_wfl) = lc;
8583           access = build_tree_list (NULL_TREE, access);
8584           access = build_method_invocation (access0_wfl, access);
8585           access = make_qualified_primary (cn, access, lc);
8586         }
8587
8588       /* If FROM isn't an inner class, that's fine, we've done enough.
8589          What we're looking for can be accessed from there.  */
8590       from = DECL_CONTEXT (TYPE_NAME (from));
8591       if (!from)
8592         break;
8593       from = TREE_TYPE (from);
8594     }
8595   return access;
8596 }
8597
8598 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8599    is returned if nothing needs to be generated. Otherwise, the method
8600    generated and a method decl is returned.
8601
8602    NOTE: These generated methods should be declared in a class file
8603    attribute so that they can't be referred to directly.  */
8604
8605 static tree
8606 maybe_build_thisn_access_method (tree type)
8607 {
8608   tree mdecl, args, stmt, rtype;
8609   tree saved_current_function_decl;
8610
8611   /* If TYPE is a top-level class, no access method is required.
8612      If there already is such an access method, bail out. */
8613   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8614     return NULL_TREE;
8615
8616   /* We generate the method. The method looks like:
8617      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8618   */
8619   args = build_tree_list (inst_id, build_pointer_type (type));
8620   TREE_CHAIN (args) = end_params_node;
8621   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8622   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8623                                     access0_identifier_node, args);
8624   fix_method_argument_names (args, mdecl);
8625   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8626   stmt = build_current_thisn (type);
8627   stmt = make_qualified_primary (build_wfl_node (inst_id),
8628                                  build_wfl_node (stmt), 0);
8629   stmt = build_return (0, stmt);
8630
8631   saved_current_function_decl = current_function_decl;
8632   start_artificial_method_body (mdecl);
8633   java_method_add_stmt (mdecl, stmt);
8634   end_artificial_method_body (mdecl);
8635   current_function_decl = saved_current_function_decl;
8636
8637   CLASS_ACCESS0_GENERATED_P (type) = 1;
8638
8639   return mdecl;
8640 }
8641
8642 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8643    the first level of innerclassing. this$1 for the next one, etc...
8644    This function can be invoked with TYPE to NULL, available and then
8645    has to count the parser context.  */
8646
8647 static GTY(()) tree saved_thisn;
8648 static GTY(()) tree saved_type;
8649
8650 static tree
8651 build_current_thisn (tree type)
8652 {
8653   static int saved_i = -1;
8654   static int saved_type_i = 0;
8655   tree decl;
8656   char buffer [24];
8657   int i = 0;
8658
8659   if (type)
8660     {
8661       if (type == saved_type)
8662         i = saved_type_i;
8663       else
8664         {
8665           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8666                decl; decl = DECL_CONTEXT (decl), i++)
8667             ;
8668
8669           saved_type = type;
8670           saved_type_i = i;
8671         }
8672     }
8673   else
8674     i = list_length (GET_CPC_LIST ())-2;
8675
8676   if (i == saved_i)
8677     return saved_thisn;
8678
8679   sprintf (buffer, "this$%d", i);
8680   saved_i = i;
8681   saved_thisn = get_identifier (buffer);
8682   return saved_thisn;
8683 }
8684
8685 /* Return the assignement to the hidden enclosing context `this$<n>'
8686    by the second incoming parameter to the innerclass constructor. The
8687    form used is `this.this$<n> = this$<n>;'.  */
8688
8689 static tree
8690 build_thisn_assign (void)
8691 {
8692   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8693     {
8694       tree thisn = build_current_thisn (current_class);
8695       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8696                                          build_wfl_node (thisn), 0);
8697       tree rhs = build_wfl_node (thisn);
8698       EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8699       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8700     }
8701   return NULL_TREE;
8702 }
8703
8704 \f
8705 /* Building the synthetic `class$' used to implement the `.class' 1.1
8706    extension for non primitive types. This method looks like:
8707
8708     static Class class$(String type) throws NoClassDefFoundError
8709     {
8710       try {return (java.lang.Class.forName (String));}
8711       catch (ClassNotFoundException e) {
8712         throw new NoClassDefFoundError(e.getMessage());}
8713     } */
8714
8715 static GTY(()) tree get_message_wfl;
8716 static GTY(()) tree type_parm_wfl;
8717
8718 static tree
8719 build_dot_class_method (tree class)
8720 {
8721 #define BWF(S) build_wfl_node (get_identifier ((S)))
8722 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8723   tree args, tmp, saved_current_function_decl, mdecl;
8724   tree stmt, throw_stmt;
8725
8726   if (!get_message_wfl)
8727     {
8728       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8729       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8730     }
8731
8732   /* Build the arguments */
8733   args = build_tree_list (get_identifier ("type$"),
8734                           build_pointer_type (string_type_node));
8735   TREE_CHAIN (args) = end_params_node;
8736
8737   /* Build the qualified name java.lang.Class.forName */
8738   tmp = MQN (MQN (MQN (BWF ("java"),
8739                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8740   load_class (class_not_found_type_node, 1);
8741   load_class (no_class_def_found_type_node, 1);
8742
8743   /* Create the "class$" function */
8744   mdecl = create_artificial_method (class, ACC_STATIC,
8745                                     build_pointer_type (class_type_node),
8746                                     classdollar_identifier_node, args);
8747   DECL_FUNCTION_THROWS (mdecl) =
8748     build_tree_list (NULL_TREE, no_class_def_found_type_node);
8749
8750   /* We start by building the try block. We need to build:
8751        return (java.lang.Class.forName (type)); */
8752   stmt = build_method_invocation (tmp,
8753                                   build_tree_list (NULL_TREE, type_parm_wfl));
8754   stmt = build_return (0, stmt);
8755
8756   /* Now onto the catch block. We start by building the expression
8757      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8758   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8759                                     get_message_wfl, 0);
8760   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8761
8762   /* Build new NoClassDefFoundError (_.getMessage) */
8763   throw_stmt = build_new_invocation
8764     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8765      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8766
8767   /* Build the throw, (it's too early to use BUILD_THROW) */
8768   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8769
8770   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8771   stmt = encapsulate_with_try_catch (0, class_not_found_type_node,
8772                                      stmt, throw_stmt);
8773
8774   fix_method_argument_names (args, mdecl);
8775   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8776   saved_current_function_decl = current_function_decl;
8777   start_artificial_method_body (mdecl);
8778   java_method_add_stmt (mdecl, stmt);
8779   end_artificial_method_body (mdecl);
8780   current_function_decl = saved_current_function_decl;
8781   TYPE_DOT_CLASS (class) = mdecl;
8782
8783   return mdecl;
8784 }
8785
8786 static tree
8787 build_dot_class_method_invocation (tree type)
8788 {
8789   tree sig_id, s;
8790
8791   if (TYPE_ARRAY_P (type))
8792     sig_id = build_java_signature (type);
8793   else
8794     sig_id = DECL_NAME (TYPE_NAME (type));
8795
8796   /* Ensure that the proper name separator is used */
8797   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8798                                IDENTIFIER_LENGTH (sig_id));
8799
8800   s = build_string (IDENTIFIER_LENGTH (sig_id),
8801                     IDENTIFIER_POINTER (sig_id));
8802   return build_method_invocation (build_wfl_node (classdollar_identifier_node),
8803                                   build_tree_list (NULL_TREE, s));
8804 }
8805
8806 /* This section of the code deals with constructor.  */
8807
8808 /* Craft a body for default constructor. Patch existing constructor
8809    bodies with call to super() and field initialization statements if
8810    necessary.  */
8811
8812 static void
8813 fix_constructors (tree mdecl)
8814 {
8815   tree iii;                     /* Instance Initializer Invocation */
8816   tree body = DECL_FUNCTION_BODY (mdecl);
8817   tree thisn_assign, compound = NULL_TREE;
8818   tree class_type = DECL_CONTEXT (mdecl);
8819
8820   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8821     return;
8822   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8823
8824   if (!body)
8825     {
8826       /* It is an error for the compiler to generate a default
8827          constructor if the superclass doesn't have a constructor that
8828          takes no argument, or the same args for an anonymous class */
8829       if (verify_constructor_super (mdecl))
8830         {
8831           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8832           tree save = DECL_NAME (mdecl);
8833           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8834           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8835           parse_error_context
8836             (lookup_cl (TYPE_NAME (class_type)),
8837              "No constructor matching `%s' found in class `%s'",
8838              lang_printable_name (mdecl, 0), n);
8839           DECL_NAME (mdecl) = save;
8840         }
8841
8842       /* The constructor body must be crafted by hand. It's the
8843          constructor we defined when we realize we didn't have the
8844          CLASSNAME() constructor */
8845       start_artificial_method_body (mdecl);
8846
8847       /* Insert an assignment to the this$<n> hidden field, if
8848          necessary */
8849       if ((thisn_assign = build_thisn_assign ()))
8850         java_method_add_stmt (mdecl, thisn_assign);
8851
8852       /* We don't generate a super constructor invocation if we're
8853          compiling java.lang.Object. build_super_invocation takes care
8854          of that. */
8855       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8856
8857       /* FIXME */
8858       if ((iii = build_instinit_invocation (class_type)))
8859         java_method_add_stmt (mdecl, iii);
8860
8861       end_artificial_method_body (mdecl);
8862     }
8863   /* Search for an explicit constructor invocation */
8864   else
8865     {
8866       int found = 0;
8867       int invokes_this = 0;
8868       tree found_call = NULL_TREE;
8869       tree main_block = BLOCK_EXPR_BODY (body);
8870
8871       while (body)
8872         switch (TREE_CODE (body))
8873           {
8874           case CALL_EXPR:
8875             found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8876             if (CALL_THIS_CONSTRUCTOR_P (body))
8877               invokes_this = 1;
8878             body = NULL_TREE;
8879             break;
8880           case COMPOUND_EXPR:
8881           case EXPR_WITH_FILE_LOCATION:
8882             found_call = body;
8883             body = TREE_OPERAND (body, 0);
8884             break;
8885           case BLOCK:
8886             found_call = body;
8887             body = BLOCK_EXPR_BODY (body);
8888             break;
8889           default:
8890             found = 0;
8891             body = NULL_TREE;
8892           }
8893
8894       /* Generate the assignment to this$<n>, if necessary */
8895       if ((thisn_assign = build_thisn_assign ()))
8896         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8897
8898       /* The constructor is missing an invocation of super() */
8899       if (!found)
8900         compound = add_stmt_to_compound (compound, NULL_TREE,
8901                                          build_super_invocation (mdecl));
8902       /* Explicit super() invokation should take place before the
8903          instance initializer blocks. */
8904       else
8905         {
8906           compound = add_stmt_to_compound (compound, NULL_TREE,
8907                                            TREE_OPERAND (found_call, 0));
8908           TREE_OPERAND (found_call, 0) = empty_stmt_node;
8909         }
8910
8911       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
8912
8913       /* Insert the instance initializer block right after. */
8914       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
8915         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
8916
8917       /* Fix the constructor main block if we're adding extra stmts */
8918       if (compound)
8919         {
8920           compound = add_stmt_to_compound (compound, NULL_TREE,
8921                                            BLOCK_EXPR_BODY (main_block));
8922           BLOCK_EXPR_BODY (main_block) = compound;
8923         }
8924     }
8925 }
8926
8927 /* Browse constructors in the super class, searching for a constructor
8928    that doesn't take any argument. Return 0 if one is found, 1
8929    otherwise.  If the current class is an anonymous inner class, look
8930    for something that has the same signature. */
8931
8932 static int
8933 verify_constructor_super (tree mdecl)
8934 {
8935   tree class = CLASSTYPE_SUPER (current_class);
8936   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8937   tree sdecl;
8938
8939   if (!class)
8940     return 0;
8941
8942   if (ANONYMOUS_CLASS_P (current_class))
8943     {
8944       tree mdecl_arg_type;
8945       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8946       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8947         if (DECL_CONSTRUCTOR_P (sdecl))
8948           {
8949             tree m_arg_type;
8950             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8951             if (super_inner)
8952               arg_type = TREE_CHAIN (arg_type);
8953             for (m_arg_type = mdecl_arg_type;
8954                  (arg_type != end_params_node
8955                   && m_arg_type != end_params_node);
8956                  arg_type = TREE_CHAIN (arg_type),
8957                    m_arg_type = TREE_CHAIN (m_arg_type))
8958               if (!valid_method_invocation_conversion_p
8959                      (TREE_VALUE (arg_type),
8960                       TREE_VALUE (m_arg_type)))
8961                 break;
8962
8963             if (arg_type == end_params_node && m_arg_type == end_params_node)
8964               return 0;
8965           }
8966     }
8967   else
8968     {
8969       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8970         {
8971           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8972           if (super_inner)
8973             arg = TREE_CHAIN (arg);
8974           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
8975             return 0;
8976         }
8977     }
8978   return 1;
8979 }
8980
8981 /* Generate code for all context remembered for code generation.  */
8982
8983 static GTY(()) tree reversed_class_list;
8984 void
8985 java_expand_classes (void)
8986 {
8987   int save_error_count = 0;
8988   static struct parser_ctxt *cur_ctxp = NULL;
8989
8990   java_parse_abort_on_error ();
8991   if (!(ctxp = ctxp_for_generation))
8992     return;
8993   java_layout_classes ();
8994   java_parse_abort_on_error ();
8995
8996   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
8997     {
8998       ctxp = cur_ctxp;
8999       input_filename = ctxp->filename;
9000       lang_init_source (2);            /* Error msgs have method prototypes */
9001       java_complete_expand_classes (); /* Complete and expand classes */
9002       java_parse_abort_on_error ();
9003     }
9004   input_filename = main_input_filename;
9005
9006
9007   /* Find anonymous classes and expand their constructor. This extra pass is
9008      neccessary because the constructor itself is only generated when the
9009      method in which it is defined is expanded. */
9010   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9011     {
9012       tree current;
9013       ctxp = cur_ctxp;
9014       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9015         {
9016           current_class = TREE_TYPE (current);
9017           if (ANONYMOUS_CLASS_P (current_class))
9018             {
9019               tree d;
9020               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9021                 {
9022                   if (DECL_CONSTRUCTOR_P (d))
9023                     {
9024                       restore_line_number_status (1);
9025                       java_complete_expand_method (d);
9026                       restore_line_number_status (0);
9027                       break;    /* There is only one constructor. */
9028                     }
9029                 }
9030             }
9031         }
9032     }
9033
9034   /* Expanding the constructors of anonymous classes generates access
9035      methods.  Scan all the methods looking for null DECL_RESULTs --
9036      this will be the case if a method hasn't been expanded.  */
9037   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9038     {
9039       tree current;
9040       ctxp = cur_ctxp;
9041       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9042         {
9043           tree d;
9044           current_class = TREE_TYPE (current);
9045           for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9046             {
9047               if (DECL_RESULT (d) == NULL_TREE)
9048                 {
9049                   restore_line_number_status (1);
9050                   java_complete_expand_method (d);
9051                   restore_line_number_status (0);
9052                 }
9053             }
9054         }
9055     }
9056
9057   /* ???  Instead of all this we could iterate around the list of
9058      classes until there were no more un-expanded methods.  It would
9059      take a little longer -- one pass over the whole list of methods
9060      -- but it would be simpler.  Like this:  */
9061 #if 0
9062     {
9063       int something_changed;
9064
9065       do
9066         {
9067           something_changed = 0;
9068           for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9069             {
9070               tree current;
9071               ctxp = cur_ctxp;
9072               for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9073                 {
9074                   tree d;
9075                   current_class = TREE_TYPE (current);
9076                   for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9077                     {
9078                       if (DECL_RESULT (d) == NULL_TREE)
9079                         {
9080                           something_changed = 1;
9081                           restore_line_number_status (1);
9082                           java_complete_expand_method (d);
9083                           restore_line_number_status (0);
9084                         }
9085                     }
9086                 }
9087             }
9088         }
9089       while (something_changed);
9090     }
9091 #endif
9092
9093   /* If we've found error at that stage, don't try to generate
9094      anything, unless we're emitting xrefs or checking the syntax only
9095      (but not using -fsyntax-only for the purpose of generating
9096      bytecode. */
9097   if (java_error_count && !flag_emit_xref
9098       && (!flag_syntax_only && !flag_emit_class_files))
9099     return;
9100
9101   /* Now things are stable, go for generation of the class data. */
9102
9103   /* We pessimistically marked all methods and fields external until
9104      we knew what set of classes we were planning to compile.  Now mark
9105      those that will be generated locally as not external.  */
9106   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9107     {
9108       tree current;
9109       ctxp = cur_ctxp;
9110       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9111         java_mark_class_local (TREE_TYPE (current));
9112     }
9113
9114   /* Compile the classes.  */
9115   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9116     {
9117       tree current;
9118       reversed_class_list = NULL;
9119
9120       ctxp = cur_ctxp;
9121
9122       /* We write out the classes in reverse order.  This ensures that
9123          inner classes are written before their containing classes,
9124          which is important for parallel builds.  Otherwise, the
9125          class file for the outer class may be found, but the class
9126          file for the inner class may not be present.  In that
9127          situation, the compiler cannot fall back to the original
9128          source, having already read the outer class, so we must
9129          prevent that situation.  */
9130       for (current = ctxp->class_list;
9131            current;
9132            current = TREE_CHAIN (current))
9133         reversed_class_list
9134           = tree_cons (NULL_TREE, current, reversed_class_list);
9135
9136       for (current = reversed_class_list;
9137            current;
9138            current = TREE_CHAIN (current))
9139         {
9140           current_class = TREE_TYPE (TREE_VALUE (current));
9141           outgoing_cpool = TYPE_CPOOL (current_class);
9142           if (flag_emit_class_files)
9143             write_classfile (current_class);
9144           if (flag_emit_xref)
9145             expand_xref (current_class);
9146           else if (! flag_syntax_only)
9147             {
9148               java_expand_method_bodies (current_class);
9149               if (!flag_unit_at_a_time)
9150                 finish_class ();
9151             }
9152         }
9153     }
9154 }
9155
9156 void
9157 java_finish_classes (void)
9158 {
9159   static struct parser_ctxt *cur_ctxp = NULL;
9160   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9161     {
9162       tree current;
9163       ctxp = cur_ctxp;
9164       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9165         {
9166           current_class = TREE_TYPE (current);
9167           outgoing_cpool = TYPE_CPOOL (current_class);
9168           finish_class ();
9169         }
9170     }
9171 }
9172
9173 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9174    a tree list node containing RIGHT. Fore coming RIGHTs will be
9175    chained to this hook. LOCATION contains the location of the
9176    separating `.' operator.  */
9177
9178 static tree
9179 make_qualified_primary (tree primary, tree right, int location)
9180 {
9181   tree wfl;
9182
9183   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9184     wfl = build_wfl_wrap (primary, location);
9185   else
9186     {
9187       wfl = primary;
9188       /* If wfl wasn't qualified, we build a first anchor */
9189       if (!EXPR_WFL_QUALIFICATION (wfl))
9190         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9191     }
9192
9193   /* And chain them */
9194   EXPR_WFL_LINECOL (right) = location;
9195   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9196   PRIMARY_P (wfl) =  1;
9197   return wfl;
9198 }
9199
9200 /* Simple merge of two name separated by a `.' */
9201
9202 static tree
9203 merge_qualified_name (tree left, tree right)
9204 {
9205   tree node;
9206   if (!left && !right)
9207     return NULL_TREE;
9208
9209   if (!left)
9210     return right;
9211
9212   if (!right)
9213     return left;
9214
9215   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9216                 IDENTIFIER_LENGTH (left));
9217   obstack_1grow (&temporary_obstack, '.');
9218   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9219                  IDENTIFIER_LENGTH (right));
9220   node =  get_identifier (obstack_base (&temporary_obstack));
9221   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9222   QUALIFIED_P (node) = 1;
9223   return node;
9224 }
9225
9226 /* Merge the two parts of a qualified name into LEFT.  Set the
9227    location information of the resulting node to LOCATION, usually
9228    inherited from the location information of the `.' operator. */
9229
9230 static tree
9231 make_qualified_name (tree left, tree right, int location)
9232 {
9233 #ifdef USE_COMPONENT_REF
9234   tree node = build (COMPONENT_REF, NULL_TREE, left, right);
9235   EXPR_WFL_LINECOL (node) = location;
9236   return node;
9237 #else
9238   tree left_id = EXPR_WFL_NODE (left);
9239   tree right_id = EXPR_WFL_NODE (right);
9240   tree wfl, merge;
9241
9242   merge = merge_qualified_name (left_id, right_id);
9243
9244   /* Left wasn't qualified and is now qualified */
9245   if (!QUALIFIED_P (left_id))
9246     {
9247       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9248       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9249       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9250     }
9251
9252   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9253   EXPR_WFL_LINECOL (wfl) = location;
9254   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9255
9256   EXPR_WFL_NODE (left) = merge;
9257   return left;
9258 #endif
9259 }
9260
9261 /* Extract the last identifier component of the qualified in WFL. The
9262    last identifier is removed from the linked list */
9263
9264 static tree
9265 cut_identifier_in_qualified (tree wfl)
9266 {
9267   tree q;
9268   tree previous = NULL_TREE;
9269   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9270     if (!TREE_CHAIN (q))
9271       {
9272         if (!previous)
9273           /* Operating on a non qualified qualified WFL.  */
9274           abort ();
9275
9276         TREE_CHAIN (previous) = NULL_TREE;
9277         return TREE_PURPOSE (q);
9278       }
9279 }
9280
9281 /* Resolve the expression name NAME. Return its decl.  */
9282
9283 static tree
9284 resolve_expression_name (tree id, tree *orig)
9285 {
9286   tree name = EXPR_WFL_NODE (id);
9287   tree decl;
9288
9289   /* 6.5.5.1: Simple expression names */
9290   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9291     {
9292       /* 15.13.1: NAME can appear within the scope of a local variable
9293          declaration */
9294       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9295         return decl;
9296
9297       /* 15.13.1: NAME can appear within a class declaration */
9298       else
9299         {
9300           decl = lookup_field_wrapper (current_class, name);
9301           if (decl)
9302             {
9303               tree access = NULL_TREE;
9304               int fs = FIELD_STATIC (decl);
9305
9306               /* If we're accessing an outer scope local alias, make
9307                  sure we change the name of the field we're going to
9308                  build access to. */
9309               if (FIELD_LOCAL_ALIAS_USED (decl))
9310                 name = DECL_NAME (decl);
9311
9312               check_deprecation (id, decl);
9313
9314               /* Instance variable (8.3.1.1) can't appear within
9315                  static method, static initializer or initializer for
9316                  a static variable. */
9317               if (!fs && METHOD_STATIC (current_function_decl))
9318                 {
9319                   static_ref_err (id, name, current_class);
9320                   return error_mark_node;
9321                 }
9322               /* Instance variables can't appear as an argument of
9323                  an explicit constructor invocation */
9324               if (!fs && ctxp->explicit_constructor_p
9325                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9326                 {
9327                   parse_error_context
9328                     (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9329                   return error_mark_node;
9330                 }
9331
9332               /* If we're processing an inner class and we're trying
9333                  to access a field belonging to an outer class, build
9334                  the access to the field */
9335               if (!fs && outer_field_access_p (current_class, decl))
9336                 {
9337                   if (CLASS_STATIC (TYPE_NAME (current_class)))
9338                     {
9339                       static_ref_err (id, DECL_NAME (decl), current_class);
9340                       return error_mark_node;
9341                     }
9342                   access = build_outer_field_access (id, decl);
9343                   if (orig)
9344                     *orig = access;
9345                   return access;
9346                 }
9347
9348               /* Otherwise build what it takes to access the field */
9349               access = build_field_ref ((fs ? NULL_TREE : current_this),
9350                                         DECL_CONTEXT (decl), name);
9351               if (fs)
9352                 access = maybe_build_class_init_for_field (decl, access);
9353               /* We may be asked to save the real field access node */
9354               if (orig)
9355                 *orig = access;
9356               /* And we return what we got */
9357               return access;
9358             }
9359           /* Fall down to error report on undefined variable */
9360         }
9361     }
9362   /* 6.5.5.2 Qualified Expression Names */
9363   else
9364     {
9365       if (orig)
9366         *orig = NULL_TREE;
9367       qualify_ambiguous_name (id);
9368       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9369       /* 15.10.2: Accessing Superclass Members using super */
9370       return resolve_field_access (id, orig, NULL);
9371     }
9372
9373   /* We've got an error here */
9374   if (INNER_CLASS_TYPE_P (current_class))
9375     parse_error_context (id,
9376                          "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9377                          IDENTIFIER_POINTER (name),
9378                          IDENTIFIER_POINTER (DECL_NAME
9379                                              (TYPE_NAME (current_class))));
9380   else
9381     parse_error_context (id, "Undefined variable `%s'",
9382                          IDENTIFIER_POINTER (name));
9383
9384   return error_mark_node;
9385 }
9386
9387 static void
9388 static_ref_err (tree wfl, tree field_id, tree class_type)
9389 {
9390   parse_error_context
9391     (wfl,
9392      "Can't make a static reference to nonstatic variable `%s' in class `%s'",
9393      IDENTIFIER_POINTER (field_id),
9394      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9395 }
9396
9397 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9398    We return something suitable to generate the field access. We also
9399    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9400    recipient's address can be null. */
9401
9402 static tree
9403 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9404 {
9405   int is_static = 0;
9406   tree field_ref;
9407   tree decl, where_found, type_found;
9408
9409   if (resolve_qualified_expression_name (qual_wfl, &decl,
9410                                          &where_found, &type_found))
9411     return error_mark_node;
9412
9413   /* Resolve the LENGTH field of an array here */
9414   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9415       && type_found && TYPE_ARRAY_P (type_found)
9416       && ! flag_emit_class_files && ! flag_emit_xref)
9417     {
9418       tree length = build_java_array_length_access (where_found);
9419       field_ref = length;
9420
9421       /* In case we're dealing with a static array, we need to
9422          initialize its class before the array length can be fetched.
9423          It's also a good time to create a DECL_RTL for the field if
9424          none already exists, otherwise if the field was declared in a
9425          class found in an external file and hasn't been (and won't
9426          be) accessed for its value, none will be created. */
9427       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9428         {
9429           build_static_field_ref (where_found);
9430           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9431         }
9432     }
9433   /* We might have been trying to resolve field.method(). In which
9434      case, the resolution is over and decl is the answer */
9435   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9436     field_ref = decl;
9437   else if (JDECL_P (decl))
9438     {
9439       if (!type_found)
9440         type_found = DECL_CONTEXT (decl);
9441       is_static = FIELD_STATIC (decl);
9442       field_ref = build_field_ref ((is_static && !flag_emit_xref?
9443                                     NULL_TREE : where_found),
9444                                    type_found, DECL_NAME (decl));
9445       if (field_ref == error_mark_node)
9446         return error_mark_node;
9447       if (is_static)
9448         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9449
9450       /* If we're looking at a static field, we may need to generate a
9451          class initialization for it.  This can happen when the access
9452          looks like `field.ref', where `field' is a static field in an
9453          interface we implement.  */
9454       if (!flag_emit_class_files
9455           && !flag_emit_xref
9456           && TREE_CODE (where_found) == VAR_DECL
9457           && 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   else
9464     field_ref = decl;
9465
9466   if (field_decl)
9467     *field_decl = decl;
9468   if (field_type)
9469     *field_type = (QUAL_DECL_TYPE (decl) ?
9470                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9471   return field_ref;
9472 }
9473
9474 /* If NODE is an access to f static field, strip out the class
9475    initialization part and return the field decl, otherwise, return
9476    NODE. */
9477
9478 static tree
9479 strip_out_static_field_access_decl (tree node)
9480 {
9481   if (TREE_CODE (node) == COMPOUND_EXPR)
9482     {
9483       tree op1 = TREE_OPERAND (node, 1);
9484       if (TREE_CODE (op1) == COMPOUND_EXPR)
9485          {
9486            tree call = TREE_OPERAND (op1, 0);
9487            if (TREE_CODE (call) == CALL_EXPR
9488                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9489                && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9490                == soft_initclass_node)
9491              return TREE_OPERAND (op1, 1);
9492          }
9493       else if (JDECL_P (op1))
9494         return op1;
9495     }
9496   return node;
9497 }
9498
9499 /* 6.5.5.2: Qualified Expression Names */
9500
9501 static int
9502 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9503                                    tree *where_found, tree *type_found)
9504 {
9505   int from_type = 0;            /* Field search initiated from a type */
9506   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9507   int previous_call_static = 0;
9508   int is_static;
9509   tree decl = NULL_TREE, type = NULL_TREE, q;
9510   /* For certain for of inner class instantiation */
9511   tree saved_current, saved_this;
9512 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9513   { current_class = saved_current; current_this = saved_this;}
9514
9515   *type_found = *where_found = NULL_TREE;
9516
9517   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9518     {
9519       tree qual_wfl = QUAL_WFL (q);
9520       tree ret_decl;            /* for EH checking */
9521       int location;             /* for EH checking */
9522
9523       /* 15.10.1 Field Access Using a Primary */
9524       switch (TREE_CODE (qual_wfl))
9525         {
9526         case CALL_EXPR:
9527         case NEW_CLASS_EXPR:
9528           /* If the access to the function call is a non static field,
9529              build the code to access it. */
9530           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9531             {
9532               decl = maybe_access_field (decl, *where_found,
9533                                          DECL_CONTEXT (decl));
9534               if (decl == error_mark_node)
9535                 return 1;
9536             }
9537
9538           /* And code for the function call */
9539           if (complete_function_arguments (qual_wfl))
9540             return 1;
9541
9542           /* We might have to setup a new current class and a new this
9543              for the search of an inner class, relative to the type of
9544              a expression resolved as `decl'. The current values are
9545              saved and restored shortly after */
9546           saved_current = current_class;
9547           saved_this = current_this;
9548           if (decl
9549               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9550                   || from_qualified_this))
9551             {
9552               /* If we still have `from_qualified_this', we have the form
9553                  <T>.this.f() and we need to build <T>.this */
9554               if (from_qualified_this)
9555                 {
9556                   decl = build_access_to_thisn (current_class, type, 0);
9557                   decl = java_complete_tree (decl);
9558                   type = TREE_TYPE (TREE_TYPE (decl));
9559                 }
9560               current_class = type;
9561               current_this = decl;
9562               from_qualified_this = 0;
9563             }
9564
9565           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9566             CALL_USING_SUPER (qual_wfl) = 1;
9567           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9568                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9569           *where_found = patch_method_invocation (qual_wfl, decl, type,
9570                                                   from_super,
9571                                                   &is_static, &ret_decl);
9572           from_super = 0;
9573           if (*where_found == error_mark_node)
9574             {
9575               RESTORE_THIS_AND_CURRENT_CLASS;
9576               return 1;
9577             }
9578           *type_found = type = QUAL_DECL_TYPE (*where_found);
9579
9580           *where_found = force_evaluation_order (*where_found);
9581
9582           /* If we're creating an inner class instance, check for that
9583              an enclosing instance is in scope */
9584           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9585               && INNER_ENCLOSING_SCOPE_CHECK (type))
9586             {
9587               parse_error_context
9588                 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
9589                  lang_printable_name (type, 0),
9590                  (!current_this ? "" :
9591                   "; an explicit one must be provided when creating this inner class"));
9592               RESTORE_THIS_AND_CURRENT_CLASS;
9593               return 1;
9594             }
9595
9596           /* In case we had to change then to resolve a inner class
9597              instantiation using a primary qualified by a `new' */
9598           RESTORE_THIS_AND_CURRENT_CLASS;
9599
9600           /* EH check. No check on access$<n> functions */
9601           if (location
9602               && !OUTER_FIELD_ACCESS_IDENTIFIER_P
9603                     (DECL_NAME (current_function_decl)))
9604             {
9605               tree arguments = NULL_TREE;
9606               if (TREE_CODE (qual_wfl) == CALL_EXPR
9607                   && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9608                 arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9609               check_thrown_exceptions (location, ret_decl, arguments);
9610             }
9611
9612           /* If the previous call was static and this one is too,
9613              build a compound expression to hold the two (because in
9614              that case, previous function calls aren't transported as
9615              forcoming function's argument. */
9616           if (previous_call_static && is_static)
9617             {
9618               decl = build (COMPOUND_EXPR, TREE_TYPE (*where_found),
9619                             decl, *where_found);
9620               TREE_SIDE_EFFECTS (decl) = 1;
9621             }
9622           else
9623             {
9624               previous_call_static = is_static;
9625               decl = *where_found;
9626             }
9627           from_type = 0;
9628           continue;
9629
9630         case NEW_ARRAY_EXPR:
9631         case NEW_ANONYMOUS_ARRAY_EXPR:
9632           *where_found = decl = java_complete_tree (qual_wfl);
9633           if (decl == error_mark_node)
9634             return 1;
9635           *type_found = type = QUAL_DECL_TYPE (decl);
9636           continue;
9637
9638         case CONVERT_EXPR:
9639           *where_found = decl = java_complete_tree (qual_wfl);
9640           if (decl == error_mark_node)
9641             return 1;
9642           *type_found = type = QUAL_DECL_TYPE (decl);
9643           from_cast = 1;
9644           continue;
9645
9646         case CONDITIONAL_EXPR:
9647         case STRING_CST:
9648         case MODIFY_EXPR:
9649           *where_found = decl = java_complete_tree (qual_wfl);
9650           if (decl == error_mark_node)
9651             return 1;
9652           *type_found = type = QUAL_DECL_TYPE (decl);
9653           continue;
9654
9655         case ARRAY_REF:
9656           /* If the access to the function call is a non static field,
9657              build the code to access it. */
9658           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9659             {
9660               decl = maybe_access_field (decl, *where_found, type);
9661               if (decl == error_mark_node)
9662                 return 1;
9663             }
9664           /* And code for the array reference expression */
9665           decl = java_complete_tree (qual_wfl);
9666           if (decl == error_mark_node)
9667             return 1;
9668           type = QUAL_DECL_TYPE (decl);
9669           continue;
9670
9671         case PLUS_EXPR:
9672           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9673             return 1;
9674           if ((type = patch_string (decl)))
9675             decl = type;
9676           *where_found = QUAL_RESOLUTION (q) = decl;
9677           *type_found = type = TREE_TYPE (decl);
9678           break;
9679
9680         case CLASS_LITERAL:
9681           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9682             return 1;
9683           *where_found = QUAL_RESOLUTION (q) = decl;
9684           *type_found = type = TREE_TYPE (decl);
9685           break;
9686
9687         default:
9688           /* Fix for -Wall Just go to the next statement. Don't
9689              continue */
9690           break;
9691         }
9692
9693       /* If we fall here, we weren't processing a (static) function call. */
9694       previous_call_static = 0;
9695
9696       /* It can be the keyword THIS */
9697       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9698           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9699         {
9700           if (!current_this)
9701             {
9702               parse_error_context
9703                 (wfl, "Keyword `this' used outside allowed context");
9704               return 1;
9705             }
9706           if (ctxp->explicit_constructor_p
9707               && type == current_class)
9708             {
9709               parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9710               return 1;
9711             }
9712           /* We have to generate code for intermediate access */
9713           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9714             {
9715               *where_found = decl = current_this;
9716               *type_found = type = QUAL_DECL_TYPE (decl);
9717             }
9718           /* We're trying to access the this from somewhere else. Make sure
9719              it's allowed before doing so. */
9720           else
9721             {
9722               if (!enclosing_context_p (type, current_class))
9723                 {
9724                   char *p  = xstrdup (lang_printable_name (type, 0));
9725                   parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9726                                        p, p,
9727                                        lang_printable_name (current_class, 0));
9728                   free (p);
9729                   return 1;
9730                 }
9731               from_qualified_this = 1;
9732               /* If there's nothing else after that, we need to
9733                  produce something now, otherwise, the section of the
9734                  code that needs to produce <T>.this will generate
9735                  what is necessary. */
9736               if (!TREE_CHAIN (q))
9737                 {
9738                   decl = build_access_to_thisn (current_class, type, 0);
9739                   *where_found = decl = java_complete_tree (decl);
9740                   *type_found = type = TREE_TYPE (decl);
9741                 }
9742             }
9743
9744           from_type = 0;
9745           continue;
9746         }
9747
9748       /* 15.10.2 Accessing Superclass Members using SUPER */
9749       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9750           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9751         {
9752           tree node;
9753           /* Check on the restricted use of SUPER */
9754           if (METHOD_STATIC (current_function_decl)
9755               || current_class == object_type_node)
9756             {
9757               parse_error_context
9758                 (wfl, "Keyword `super' used outside allowed context");
9759               return 1;
9760             }
9761           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9762           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9763                              CLASSTYPE_SUPER (current_class),
9764                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9765           *where_found = decl = java_complete_tree (node);
9766           if (decl == error_mark_node)
9767             return 1;
9768           *type_found = type = QUAL_DECL_TYPE (decl);
9769           from_super = from_type = 1;
9770           continue;
9771         }
9772
9773       /* 15.13.1: Can't search for field name in packages, so we
9774          assume a variable/class name was meant. */
9775       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9776         {
9777           tree name;
9778           if ((decl = resolve_package (wfl, &q, &name)))
9779             {
9780               tree list;
9781               *where_found = decl;
9782
9783               /* We want to be absolutely sure that the class is laid
9784                  out. We're going to search something inside it. */
9785               *type_found = type = TREE_TYPE (decl);
9786               layout_class (type);
9787               from_type = 1;
9788
9789               /* Fix them all the way down, if any are left. */
9790               if (q)
9791                 {
9792                   list = TREE_CHAIN (q);
9793                   while (list)
9794                     {
9795                       RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (list)) = 1;
9796                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9797                       list = TREE_CHAIN (list);
9798                     }
9799                 }
9800             }
9801           else
9802             {
9803               if (from_super || from_cast)
9804                 parse_error_context
9805                   ((from_cast ? qual_wfl : wfl),
9806                    "No variable `%s' defined in class `%s'",
9807                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9808                    lang_printable_name (type, 0));
9809               else
9810                 parse_error_context
9811                   (qual_wfl, "Undefined variable or class name: `%s'",
9812                    IDENTIFIER_POINTER (name));
9813               return 1;
9814             }
9815         }
9816
9817       /* We have a type name. It's been already resolved when the
9818          expression was qualified. */
9819       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9820         {
9821           decl = QUAL_RESOLUTION (q);
9822
9823           /* Sneak preview. If next we see a `new', we're facing a
9824              qualification with resulted in a type being selected
9825              instead of a field.  Report the error */
9826           if(TREE_CHAIN (q)
9827              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9828             {
9829               parse_error_context (qual_wfl, "Undefined variable `%s'",
9830                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9831               return 1;
9832             }
9833
9834           if (not_accessible_p (TREE_TYPE (decl), decl, type, 0))
9835             {
9836               parse_error_context
9837                 (qual_wfl, "Can't access %s field `%s.%s' from `%s'",
9838                  java_accstring_lookup (get_access_flags_from_decl (decl)),
9839                  GET_TYPE_NAME (type),
9840                  IDENTIFIER_POINTER (DECL_NAME (decl)),
9841                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
9842               return 1;
9843             }
9844           check_deprecation (qual_wfl, decl);
9845
9846           type = TREE_TYPE (decl);
9847           from_type = 1;
9848         }
9849       /* We resolve an expression name */
9850       else
9851         {
9852           tree field_decl = NULL_TREE;
9853
9854           /* If there exists an early resolution, use it. That occurs
9855              only once and we know that there are more things to
9856              come. Don't do that when processing something after SUPER
9857              (we need more thing to be put in place below */
9858           if (!from_super && QUAL_RESOLUTION (q))
9859             {
9860               decl = QUAL_RESOLUTION (q);
9861               if (!type)
9862                 {
9863                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9864                     {
9865                       if (current_this)
9866                         *where_found = current_this;
9867                       else
9868                         {
9869                           static_ref_err (qual_wfl, DECL_NAME (decl),
9870                                           current_class);
9871                           return 1;
9872                         }
9873                       if (outer_field_access_p (current_class, decl))
9874                         decl = build_outer_field_access (qual_wfl, decl);
9875                     }
9876                   else
9877                     {
9878                       *where_found = TREE_TYPE (decl);
9879                       if (TREE_CODE (*where_found) == POINTER_TYPE)
9880                         *where_found = TREE_TYPE (*where_found);
9881                     }
9882                 }
9883             }
9884
9885           /* Report and error if we're using a numerical litteral as a
9886              qualifier. It can only be an INTEGER_CST. */
9887           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9888             {
9889               parse_error_context
9890                 (wfl, "Can't use type `%s' as a qualifier",
9891                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
9892               return 1;
9893             }
9894
9895           /* We have to search for a field, knowing the type of its
9896              container. The flag FROM_TYPE indicates that we resolved
9897              the last member of the expression as a type name, which
9898              means that for the resolution of this field, we'll look
9899              for other errors than if it was resolved as a member of
9900              an other field. */
9901           else
9902             {
9903               int is_static;
9904               tree field_decl_type; /* For layout */
9905
9906               if (!from_type && !JREFERENCE_TYPE_P (type))
9907                 {
9908                   parse_error_context
9909                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9910                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9911                      lang_printable_name (type, 0),
9912                      IDENTIFIER_POINTER (DECL_NAME (decl)));
9913                   return 1;
9914                 }
9915
9916               field_decl = lookup_field_wrapper (type,
9917                                                  EXPR_WFL_NODE (qual_wfl));
9918
9919               /* Maybe what we're trying to access to is an inner
9920                  class, only if decl is a TYPE_DECL. */
9921               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9922                 {
9923                   tree ptr, inner_decl;
9924
9925                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9926                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9927                   if (inner_decl)
9928                     {
9929                       check_inner_class_access (inner_decl, decl, qual_wfl);
9930                       type = TREE_TYPE (inner_decl);
9931                       decl = inner_decl;
9932                       from_type = 1;
9933                       continue;
9934                     }
9935                 }
9936
9937               if (field_decl == NULL_TREE)
9938                 {
9939                   parse_error_context
9940                     (qual_wfl, "No variable `%s' defined in type `%s'",
9941                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9942                      GET_TYPE_NAME (type));
9943                   return 1;
9944                 }
9945               if (field_decl == error_mark_node)
9946                 return 1;
9947
9948               /* Layout the type of field_decl, since we may need
9949                  it. Don't do primitive types or loaded classes. The
9950                  situation of non primitive arrays may not handled
9951                  properly here. FIXME */
9952               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9953                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9954               else
9955                 field_decl_type = TREE_TYPE (field_decl);
9956               if (!JPRIMITIVE_TYPE_P (field_decl_type)
9957                   && !CLASS_LOADED_P (field_decl_type)
9958                   && !TYPE_ARRAY_P (field_decl_type))
9959                 resolve_and_layout (field_decl_type, NULL_TREE);
9960
9961               /* Check on accessibility here */
9962               if (not_accessible_p (current_class, field_decl,
9963                                     DECL_CONTEXT (field_decl), from_super))
9964                 {
9965                   parse_error_context
9966                     (qual_wfl,
9967                      "Can't access %s field `%s.%s' from `%s'",
9968                      java_accstring_lookup
9969                        (get_access_flags_from_decl (field_decl)),
9970                      GET_TYPE_NAME (type),
9971                      IDENTIFIER_POINTER (DECL_NAME (field_decl)),
9972                      IDENTIFIER_POINTER
9973                        (DECL_NAME (TYPE_NAME (current_class))));
9974                   return 1;
9975                 }
9976               check_deprecation (qual_wfl, field_decl);
9977
9978               /* There are things to check when fields are accessed
9979                  from type. There are no restrictions on a static
9980                  declaration of the field when it is accessed from an
9981                  interface */
9982               is_static = FIELD_STATIC (field_decl);
9983               if (!from_super && from_type
9984                   && !TYPE_INTERFACE_P (type)
9985                   && !is_static
9986                   && (current_function_decl
9987                       && METHOD_STATIC (current_function_decl)))
9988                 {
9989                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
9990                   return 1;
9991                 }
9992               from_cast = from_super = 0;
9993
9994               /* It's an access from a type but it isn't static, we
9995                  make it relative to `this'. */
9996               if (!is_static && from_type)
9997                 decl = current_this;
9998
9999               /* If we need to generate something to get a proper
10000                  handle on what this field is accessed from, do it
10001                  now. */
10002               if (!is_static)
10003                 {
10004                   decl = maybe_access_field (decl, *where_found, *type_found);
10005                   if (decl == error_mark_node)
10006                     return 1;
10007                 }
10008
10009               /* We want to keep the location were found it, and the type
10010                  we found. */
10011               *where_found = decl;
10012               *type_found = type;
10013
10014               /* Generate the correct expression for field access from
10015                  qualified this */
10016               if (from_qualified_this)
10017                 {
10018                   field_decl = build_outer_field_access (qual_wfl, field_decl);
10019                   from_qualified_this = 0;
10020                 }
10021
10022               /* This is the decl found and eventually the next one to
10023                  search from */
10024               decl = field_decl;
10025             }
10026           from_type = 0;
10027           type = QUAL_DECL_TYPE (decl);
10028
10029           /* Sneak preview. If decl is qualified by a `new', report
10030              the error here to be accurate on the peculiar construct */
10031           if (TREE_CHAIN (q)
10032               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10033               && !JREFERENCE_TYPE_P (type))
10034             {
10035               parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
10036                                    lang_printable_name (type, 0));
10037               return 1;
10038             }
10039         }
10040       /* `q' might have changed due to a after package resolution
10041          re-qualification */
10042       if (!q)
10043         break;
10044     }
10045   *found_decl = decl;
10046   return 0;
10047 }
10048
10049 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10050    can't be accessed from REFERENCE (a record type). If MEMBER
10051    features a protected access, we then use WHERE which, if non null,
10052    holds the type of MEMBER's access that is checked against
10053    6.6.2.1. This function should be used when decl is a field or a
10054    method.  */
10055
10056 static int
10057 not_accessible_p (tree reference, tree member, tree where, int from_super)
10058 {
10059   int access_flag = get_access_flags_from_decl (member);
10060
10061   /* Inner classes are processed by check_inner_class_access */
10062   if (INNER_CLASS_TYPE_P (reference))
10063     return 0;
10064
10065   /* Access always granted for members declared public */
10066   if (access_flag & ACC_PUBLIC)
10067     return 0;
10068
10069   /* Check access on protected members */
10070   if (access_flag & ACC_PROTECTED)
10071     {
10072       /* Access granted if it occurs from within the package
10073          containing the class in which the protected member is
10074          declared */
10075       if (class_in_current_package (DECL_CONTEXT (member)))
10076         return 0;
10077
10078       /* If accessed with the form `super.member', then access is granted */
10079       if (from_super)
10080         return 0;
10081
10082       /* If where is active, access was made through a
10083          qualifier. Access is granted if the type of the qualifier is
10084          or is a sublass of the type the access made from (6.6.2.1.)  */
10085       if (where && !inherits_from_p (reference, where))
10086         return 1;
10087
10088       /* Otherwise, access is granted if occurring from the class where
10089          member is declared or a subclass of it. Find the right
10090          context to perform the check */
10091       if (PURE_INNER_CLASS_TYPE_P (reference))
10092         {
10093           while (INNER_CLASS_TYPE_P (reference))
10094             {
10095               if (inherits_from_p (reference, DECL_CONTEXT (member)))
10096                 return 0;
10097               reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10098             }
10099         }
10100       if (inherits_from_p (reference, DECL_CONTEXT (member)))
10101         return 0;
10102       return 1;
10103     }
10104
10105   /* Check access on private members. Access is granted only if it
10106      occurs from within the class in which it is declared -- that does
10107      it for innerclasses too. */
10108   if (access_flag & ACC_PRIVATE)
10109     {
10110       if (reference == DECL_CONTEXT (member))
10111         return 0;
10112       if (enclosing_context_p (reference, DECL_CONTEXT (member)))
10113         return 0;
10114       return 1;
10115     }
10116
10117   /* Default access are permitted only when occurring within the
10118      package in which the type (REFERENCE) is declared. In other words,
10119      REFERENCE is defined in the current package */
10120   if (ctxp->package)
10121     return !class_in_current_package (reference);
10122
10123   /* Otherwise, access is granted */
10124   return 0;
10125 }
10126
10127 /* Test deprecated decl access.  */
10128 static void
10129 check_deprecation (tree wfl, tree decl)
10130 {
10131   const char *file;
10132   tree elt;
10133
10134   if (! flag_deprecated)
10135     return;
10136
10137   /* We want to look at the element type of arrays here, so we strip
10138      all surrounding array types.  */
10139   if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10140     {
10141       elt = TREE_TYPE (decl);
10142       while (TYPE_ARRAY_P (elt))
10143         elt = TYPE_ARRAY_ELEMENT (elt);
10144       /* We'll end up with a pointer type, so we use TREE_TYPE to go
10145          to the record.  */
10146       decl = TYPE_NAME (TREE_TYPE (elt));
10147     }
10148   file = DECL_SOURCE_FILE (decl);
10149
10150   /* Complain if the field is deprecated and the file it was defined
10151      in isn't compiled at the same time the file which contains its
10152      use is */
10153   if (DECL_DEPRECATED (decl)
10154       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10155     {
10156       const char *the;
10157       switch (TREE_CODE (decl))
10158         {
10159         case FUNCTION_DECL:
10160           the = "method";
10161           break;
10162         case FIELD_DECL:
10163         case VAR_DECL:
10164           the = "field";
10165           break;
10166         case TYPE_DECL:
10167           parse_warning_context (wfl, "The class `%s' has been deprecated",
10168                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10169           return;
10170         default:
10171           abort ();
10172         }
10173       /* Don't issue a message if the context as been deprecated as a
10174          whole. */
10175       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10176         parse_warning_context
10177           (wfl, "The %s `%s' in class `%s' has been deprecated",
10178            the, lang_printable_name (decl, 0),
10179            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10180     }
10181 }
10182
10183 /* Returns 1 if class was declared in the current package, 0 otherwise */
10184
10185 static GTY(()) tree cicp_cache;
10186 static int
10187 class_in_current_package (tree class)
10188 {
10189   int qualified_flag;
10190   tree left;
10191
10192   if (cicp_cache == class)
10193     return 1;
10194
10195   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10196
10197   /* If the current package is empty and the name of CLASS is
10198      qualified, class isn't in the current package.  If there is a
10199      current package and the name of the CLASS is not qualified, class
10200      isn't in the current package */
10201   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10202     return 0;
10203
10204   /* If there is not package and the name of CLASS isn't qualified,
10205      they belong to the same unnamed package */
10206   if (!ctxp->package && !qualified_flag)
10207     return 1;
10208
10209   /* Compare the left part of the name of CLASS with the package name */
10210   breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10211   if (ctxp->package == left)
10212     {
10213       cicp_cache = class;
10214       return 1;
10215     }
10216   return 0;
10217 }
10218
10219 /* This function may generate code to access DECL from WHERE. This is
10220    done only if certain conditions meet.  */
10221
10222 static tree
10223 maybe_access_field (tree decl, tree where, tree type)
10224 {
10225   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10226       && !FIELD_STATIC (decl))
10227     decl = build_field_ref (where ? where : current_this,
10228                             (type ? type : DECL_CONTEXT (decl)),
10229                             DECL_NAME (decl));
10230   return decl;
10231 }
10232
10233 /* Build a method invocation, by patching PATCH. If non NULL
10234    and according to the situation, PRIMARY and WHERE may be
10235    used. IS_STATIC is set to 1 if the invoked function is static. */
10236
10237 static tree
10238 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10239                          int *is_static, tree *ret_decl)
10240 {
10241   tree wfl = TREE_OPERAND (patch, 0);
10242   tree args = TREE_OPERAND (patch, 1);
10243   tree name = EXPR_WFL_NODE (wfl);
10244   tree list;
10245   int is_static_flag = 0;
10246   int is_super_init = 0;
10247   tree this_arg = NULL_TREE;
10248   int is_array_clone_call = 0;
10249
10250   /* Should be overridden if everything goes well. Otherwise, if
10251      something fails, it should keep this value. It stop the
10252      evaluation of a bogus assignment. See java_complete_tree,
10253      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10254      evaluating an assignment */
10255   TREE_TYPE (patch) = error_mark_node;
10256
10257   /* Since lookup functions are messing with line numbers, save the
10258      context now.  */
10259   java_parser_context_save_global ();
10260
10261   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10262
10263   /* Resolution of qualified name, excluding constructors */
10264   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10265     {
10266       tree identifier, identifier_wfl, type, resolved;
10267       /* Extract the last IDENTIFIER of the qualified
10268          expression. This is a wfl and we will use it's location
10269          data during error report. */
10270       identifier_wfl = cut_identifier_in_qualified (wfl);
10271       identifier = EXPR_WFL_NODE (identifier_wfl);
10272
10273       /* Given the context, IDENTIFIER is syntactically qualified
10274          as a MethodName. We need to qualify what's before */
10275       qualify_ambiguous_name (wfl);
10276       resolved = resolve_field_access (wfl, NULL, NULL);
10277
10278       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10279          && FIELD_FINAL (resolved)
10280          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10281          && !flag_emit_class_files && !flag_emit_xref)
10282        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10283
10284       if (resolved == error_mark_node)
10285         PATCH_METHOD_RETURN_ERROR ();
10286
10287       type = GET_SKIP_TYPE (resolved);
10288       resolve_and_layout (type, NULL_TREE);
10289
10290       if (JPRIMITIVE_TYPE_P (type))
10291         {
10292           parse_error_context
10293             (identifier_wfl,
10294              "Can't invoke a method on primitive type `%s'",
10295              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10296           PATCH_METHOD_RETURN_ERROR ();
10297         }
10298
10299       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10300       args = nreverse (args);
10301
10302       /* We're resolving a call from a type */
10303       if (TREE_CODE (resolved) == TYPE_DECL)
10304         {
10305           if (CLASS_INTERFACE (resolved))
10306             {
10307               parse_error_context
10308                 (identifier_wfl,
10309                 "Can't make static reference to method `%s' in interface `%s'",
10310                  IDENTIFIER_POINTER (identifier),
10311                  IDENTIFIER_POINTER (name));
10312               PATCH_METHOD_RETURN_ERROR ();
10313             }
10314           if (list && !METHOD_STATIC (list))
10315             {
10316               char *fct_name = xstrdup (lang_printable_name (list, 0));
10317               parse_error_context
10318                 (identifier_wfl,
10319                  "Can't make static reference to method `%s %s' in class `%s'",
10320                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10321                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10322               free (fct_name);
10323               PATCH_METHOD_RETURN_ERROR ();
10324             }
10325         }
10326       else
10327         this_arg = primary = resolved;
10328
10329       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10330         is_array_clone_call = 1;
10331
10332       /* IDENTIFIER_WFL will be used to report any problem further */
10333       wfl = identifier_wfl;
10334     }
10335   /* Resolution of simple names, names generated after a primary: or
10336      constructors */
10337   else
10338     {
10339       tree class_to_search = NULL_TREE;
10340       int lc;                   /* Looking for Constructor */
10341
10342       /* We search constructor in their target class */
10343       if (CALL_CONSTRUCTOR_P (patch))
10344         {
10345           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10346             class_to_search = EXPR_WFL_NODE (wfl);
10347           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10348                    this_identifier_node)
10349             class_to_search = NULL_TREE;
10350           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10351                    super_identifier_node)
10352             {
10353               is_super_init = 1;
10354               if (CLASSTYPE_SUPER (current_class))
10355                 class_to_search =
10356                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10357               else
10358                 {
10359                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10360                   PATCH_METHOD_RETURN_ERROR ();
10361                 }
10362             }
10363
10364           /* Class to search is NULL if we're searching the current one */
10365           if (class_to_search)
10366             {
10367               class_to_search = resolve_and_layout (class_to_search, wfl);
10368
10369               if (!class_to_search)
10370                 {
10371                   parse_error_context
10372                     (wfl, "Class `%s' not found in type declaration",
10373                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10374                   PATCH_METHOD_RETURN_ERROR ();
10375                 }
10376
10377               /* Can't instantiate an abstract class, but we can
10378                  invoke it's constructor. It's use within the `new'
10379                  context is denied here. */
10380               if (CLASS_ABSTRACT (class_to_search)
10381                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10382                 {
10383                   parse_error_context
10384                     (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10385                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10386                   PATCH_METHOD_RETURN_ERROR ();
10387                 }
10388
10389               class_to_search = TREE_TYPE (class_to_search);
10390             }
10391           else
10392             class_to_search = current_class;
10393           lc = 1;
10394         }
10395       /* This is a regular search in the local class, unless an
10396          alternate class is specified. */
10397       else
10398         {
10399           if (where != NULL_TREE)
10400             class_to_search = where;
10401           else if (QUALIFIED_P (name))
10402             class_to_search = current_class;
10403           else
10404             {
10405               class_to_search = current_class;
10406
10407               for (;;)
10408                 {
10409                   if (has_method (class_to_search, name))
10410                     break;
10411                   if (! INNER_CLASS_TYPE_P (class_to_search))
10412                     {
10413                       parse_error_context (wfl,
10414                                            "No method named `%s' in scope",
10415                                            IDENTIFIER_POINTER (name));
10416                       PATCH_METHOD_RETURN_ERROR ();
10417                     }
10418                   class_to_search
10419                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10420                 }
10421             }
10422           lc = 0;
10423         }
10424
10425       /* NAME is a simple identifier or comes from a primary. Search
10426          in the class whose declaration contain the method being
10427          invoked. */
10428       resolve_and_layout (class_to_search, NULL_TREE);
10429
10430       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10431       /* Don't continue if no method were found, as the next statement
10432          can't be executed then. */
10433       if (!list)
10434         PATCH_METHOD_RETURN_ERROR ();
10435
10436       if (TYPE_ARRAY_P (class_to_search)
10437           && DECL_NAME (list) == get_identifier ("clone"))
10438         is_array_clone_call = 1;
10439
10440       /* Check for static reference if non static methods */
10441       if (check_for_static_method_reference (wfl, patch, list,
10442                                              class_to_search, primary))
10443         PATCH_METHOD_RETURN_ERROR ();
10444
10445       /* Check for inner classes creation from illegal contexts */
10446       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10447                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10448           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10449           && !DECL_INIT_P (current_function_decl))
10450         {
10451           parse_error_context
10452             (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10453              lang_printable_name (class_to_search, 0),
10454              (!current_this ? "" :
10455               "; an explicit one must be provided when creating this inner class"));
10456           PATCH_METHOD_RETURN_ERROR ();
10457         }
10458
10459       /* Non static methods are called with the current object extra
10460          argument. If patch a `new TYPE()', the argument is the value
10461          returned by the object allocator. If method is resolved as a
10462          primary, use the primary otherwise use the current THIS. */
10463       args = nreverse (args);
10464       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10465         {
10466           this_arg = primary ? primary : current_this;
10467
10468           /* If we're using an access method, things are different.
10469              There are two familly of cases:
10470
10471              1) We're not generating bytecodes:
10472
10473              - LIST is non static. It's invocation is transformed from
10474                x(a1,...,an) into this$<n>.x(a1,....an).
10475              - LIST is static. It's invocation is transformed from
10476                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10477
10478              2) We're generating bytecodes:
10479
10480              - LIST is non static. It's invocation is transformed from
10481                x(a1,....,an) into access$<n>(this$<n>,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              Of course, this$<n> can be abitrary complex, ranging from
10486              this$0 (the immediate outer context) to
10487              access$0(access$0(...(this$0))).
10488
10489              maybe_use_access_method returns a nonzero value if the
10490              this_arg has to be moved into the (then generated) stub
10491              argument list. In the meantime, the selected function
10492              might have be replaced by a generated stub. */
10493           if (!primary &&
10494               maybe_use_access_method (is_super_init, &list, &this_arg))
10495             {
10496               args = tree_cons (NULL_TREE, this_arg, args);
10497               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10498             }
10499         }
10500     }
10501
10502   /* Merge point of all resolution schemes. If we have nothing, this
10503      is an error, already signaled */
10504   if (!list)
10505     PATCH_METHOD_RETURN_ERROR ();
10506
10507   /* Check accessibility, position the is_static flag, build and
10508      return the call */
10509   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10510                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10511                          NULL_TREE), from_super)
10512       /* Calls to clone() on array types are permitted as a special-case. */
10513       && !is_array_clone_call)
10514     {
10515       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10516       const char *const access =
10517         java_accstring_lookup (get_access_flags_from_decl (list));
10518       const char *const klass =
10519         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10520       const char *const refklass =
10521         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10522       const char *const what = (DECL_CONSTRUCTOR_P (list)
10523                                 ? "constructor" : "method");
10524       /* FIXME: WFL yields the wrong message here but I don't know
10525          what else to use.  */
10526       parse_error_context (wfl,
10527                            "Can't access %s %s `%s.%s' from `%s'",
10528                            access, what, klass, fct_name, refklass);
10529       PATCH_METHOD_RETURN_ERROR ();
10530     }
10531
10532   /* Deprecation check: check whether the method being invoked or the
10533      instance-being-created's type are deprecated.  */
10534   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10535     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10536   check_deprecation (wfl, list);
10537
10538   /* If invoking a innerclass constructor, there are hidden parameters
10539      to pass */
10540   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10541       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10542     {
10543       /* And make sure we add the accessed local variables to be saved
10544          in field aliases. */
10545       args = build_alias_initializer_parameter_list
10546         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10547
10548       /* Secretly pass the current_this/primary as a second argument */
10549       if (primary || current_this)
10550         {
10551           tree extra_arg;
10552           tree this_type = (current_this ?
10553                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10554           /* Method's (list) enclosing context */
10555           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10556           /* If we have a primary, use it. */
10557           if (primary)
10558             extra_arg = primary;
10559           /* The current `this' is an inner class but isn't a direct
10560              enclosing context for the inner class we're trying to
10561              create. Build an access to the proper enclosing context
10562              and use it. */
10563           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10564                    && this_type != TREE_TYPE (mec))
10565             {
10566
10567               extra_arg = build_access_to_thisn (current_class,
10568                                                  TREE_TYPE (mec), 0);
10569               extra_arg = java_complete_tree (extra_arg);
10570             }
10571           /* Otherwise, just use the current `this' as an enclosing
10572              context. */
10573           else
10574             extra_arg = current_this;
10575           args = tree_cons (NULL_TREE, extra_arg, args);
10576         }
10577       else
10578         args = tree_cons (NULL_TREE, integer_zero_node, args);
10579     }
10580
10581   /* This handles the situation where a constructor invocation needs
10582      to have an enclosing context passed as a second parameter (the
10583      constructor is one of an inner class). */
10584   if ((is_super_init ||
10585        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10586       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10587     {
10588       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10589       tree extra_arg =
10590         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10591       extra_arg = java_complete_tree (extra_arg);
10592       args = tree_cons (NULL_TREE, extra_arg, args);
10593     }
10594
10595   is_static_flag = METHOD_STATIC (list);
10596   if (! is_static_flag && this_arg != NULL_TREE)
10597     args = tree_cons (NULL_TREE, this_arg, args);
10598
10599   /* In the context of an explicit constructor invocation, we can't
10600      invoke any method relying on `this'. Exceptions are: we're
10601      invoking a static function, primary exists and is not the current
10602      this, we're creating a new object. */
10603   if (ctxp->explicit_constructor_p
10604       && !is_static_flag
10605       && (!primary || primary == current_this)
10606       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10607     {
10608       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10609       PATCH_METHOD_RETURN_ERROR ();
10610     }
10611   java_parser_context_restore_global ();
10612   if (is_static)
10613     *is_static = is_static_flag;
10614   /* Sometimes, we want the decl of the selected method. Such as for
10615      EH checking */
10616   if (ret_decl)
10617     *ret_decl = list;
10618   patch = patch_invoke (patch, list, args);
10619
10620   /* Now is a good time to insert the call to finit$ */
10621   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10622     {
10623       tree finit_parms, finit_call;
10624
10625       /* Prepare to pass hidden parameters to finit$, if any. */
10626       finit_parms = build_alias_initializer_parameter_list
10627         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10628
10629       finit_call =
10630         build_method_invocation (build_wfl_node (finit_identifier_node),
10631                                  finit_parms);
10632
10633       /* Generate the code used to initialize fields declared with an
10634          initialization statement and build a compound statement along
10635          with the super constructor invocation. */
10636       CAN_COMPLETE_NORMALLY (patch) = 1;
10637       patch = build (COMPOUND_EXPR, void_type_node, patch,
10638                      java_complete_tree (finit_call));
10639     }
10640   return patch;
10641 }
10642
10643 /* Check that we're not trying to do a static reference to a method in
10644    non static method. Return 1 if it's the case, 0 otherwise. */
10645
10646 static int
10647 check_for_static_method_reference (tree wfl, tree node, tree method,
10648                                    tree where, tree primary)
10649 {
10650   if (METHOD_STATIC (current_function_decl)
10651       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10652     {
10653       char *fct_name = xstrdup (lang_printable_name (method, 0));
10654       parse_error_context
10655         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10656          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10657          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10658       free (fct_name);
10659       return 1;
10660     }
10661   return 0;
10662 }
10663
10664 /* Fix the invocation of *MDECL if necessary in the case of a
10665    invocation from an inner class. *THIS_ARG might be modified
10666    appropriately and an alternative access to *MDECL might be
10667    returned.  */
10668
10669 static int
10670 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10671 {
10672   tree ctx;
10673   tree md = *mdecl, ta = *this_arg;
10674   int to_return = 0;
10675   int non_static_context = !METHOD_STATIC (md);
10676
10677   if (is_super_init
10678       || DECL_CONTEXT (md) == current_class
10679       || !PURE_INNER_CLASS_TYPE_P (current_class)
10680       || DECL_FINIT_P (md)
10681       || DECL_INSTINIT_P (md))
10682     return 0;
10683
10684   /* If we're calling a method found in an enclosing class, generate
10685      what it takes to retrieve the right this. Don't do that if we're
10686      invoking a static method. Note that if MD's type is unrelated to
10687      CURRENT_CLASS, then the current this can be used. */
10688
10689   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10690     {
10691       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10692       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10693         {
10694           ta = build_current_thisn (current_class);
10695           ta = build_wfl_node (ta);
10696         }
10697       else
10698         {
10699           tree type = ctx;
10700           while (type)
10701             {
10702               maybe_build_thisn_access_method (type);
10703               if (inherits_from_p (type, DECL_CONTEXT (md)))
10704                 {
10705                   ta = build_access_to_thisn (ctx, type, 0);
10706                   break;
10707                 }
10708               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10709                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10710             }
10711         }
10712       ta = java_complete_tree (ta);
10713     }
10714
10715   /* We might have to use an access method to get to MD. We can
10716      break the method access rule as far as we're not generating
10717      bytecode */
10718   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10719     {
10720       md = build_outer_method_access_method (md);
10721       to_return = 1;
10722     }
10723
10724   *mdecl = md;
10725   *this_arg = ta;
10726
10727   /* Returnin a nonzero value indicates we were doing a non static
10728      method invokation that is now a static invocation. It will have
10729      callee displace `this' to insert it in the regular argument
10730      list. */
10731   return (non_static_context && to_return);
10732 }
10733
10734 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10735    mode.  */
10736
10737 static tree
10738 patch_invoke (tree patch, tree method, tree args)
10739 {
10740   tree dtable, func;
10741   tree original_call, t, ta;
10742   tree check = NULL_TREE;
10743
10744   /* Last step for args: convert build-in types. If we're dealing with
10745      a new TYPE() type call, the first argument to the constructor
10746      isn't found in the incoming argument list, but delivered by
10747      `new' */
10748   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10749   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10750     t = TREE_CHAIN (t);
10751   for (ta = args; t != end_params_node && ta;
10752        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10753     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10754         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10755       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10756
10757   /* Resolve unresolved returned type isses */
10758   t = TREE_TYPE (TREE_TYPE (method));
10759   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10760     resolve_and_layout (TREE_TYPE (t), NULL);
10761
10762   if (flag_emit_class_files || flag_emit_xref)
10763     func = method;
10764   else
10765     {
10766       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10767         {
10768         case INVOKE_VIRTUAL:
10769           dtable = invoke_build_dtable (0, args);
10770           func = build_invokevirtual (dtable, method);
10771           break;
10772
10773         case INVOKE_NONVIRTUAL:
10774           /* If the object for the method call is null, we throw an
10775              exception.  We don't do this if the object is the current
10776              method's `this'.  In other cases we just rely on an
10777              optimization pass to eliminate redundant checks.  */
10778           if (TREE_VALUE (args) != current_this)
10779             {
10780               /* We use a save_expr here to make sure we only evaluate
10781                  the new `self' expression once.  */
10782               tree save_arg = save_expr (TREE_VALUE (args));
10783               TREE_VALUE (args) = save_arg;
10784               check = java_check_reference (save_arg, 1);
10785             }
10786           /* Fall through.  */
10787
10788         case INVOKE_SUPER:
10789         case INVOKE_STATIC:
10790           {
10791             tree signature = build_java_signature (TREE_TYPE (method));
10792             func = build_known_method_ref (method, TREE_TYPE (method),
10793                                            DECL_CONTEXT (method),
10794                                            signature, args);
10795           }
10796           break;
10797
10798         case INVOKE_INTERFACE:
10799           dtable = invoke_build_dtable (1, args);
10800           func = build_invokeinterface (dtable, method);
10801           break;
10802
10803         default:
10804           abort ();
10805         }
10806
10807       /* Ensure self_type is initialized, (invokestatic). FIXME */
10808       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10809     }
10810
10811   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10812   TREE_OPERAND (patch, 0) = func;
10813   TREE_OPERAND (patch, 1) = args;
10814   patch = check_for_builtin (method, patch);
10815   original_call = patch;
10816
10817   /* We're processing a `new TYPE ()' form. New is called and its
10818      returned value is the first argument to the constructor. We build
10819      a COMPOUND_EXPR and use saved expression so that the overall NEW
10820      expression value is a pointer to a newly created and initialized
10821      class. */
10822   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10823     {
10824       tree class = DECL_CONTEXT (method);
10825       tree c1, saved_new, size, new;
10826       tree alloc_node;
10827
10828       if (flag_emit_class_files || flag_emit_xref)
10829         {
10830           TREE_TYPE (patch) = build_pointer_type (class);
10831           return patch;
10832         }
10833       if (!TYPE_SIZE (class))
10834         safe_layout_class (class);
10835       size = size_in_bytes (class);
10836       alloc_node =
10837         (class_has_finalize_method (class) ? alloc_object_node
10838                                            : alloc_no_finalizer_node);
10839       new = build (CALL_EXPR, promote_type (class),
10840                    build_address_of (alloc_node),
10841                    tree_cons (NULL_TREE, build_class_ref (class),
10842                               build_tree_list (NULL_TREE,
10843                                                size_in_bytes (class))),
10844                    NULL_TREE);
10845       saved_new = save_expr (new);
10846       c1 = build_tree_list (NULL_TREE, saved_new);
10847       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10848       TREE_OPERAND (original_call, 1) = c1;
10849       TREE_SET_CODE (original_call, CALL_EXPR);
10850       patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10851     }
10852
10853   /* If CHECK is set, then we are building a check to see if the object
10854      is NULL.  */
10855   if (check != NULL_TREE)
10856     {
10857       /* We have to call force_evaluation_order now because creating a
10858          COMPOUND_EXPR wraps the arg list in a way that makes it
10859          unrecognizable by force_evaluation_order later.  Yuk.  */
10860       patch = build (COMPOUND_EXPR, TREE_TYPE (patch), check,
10861                      force_evaluation_order (patch));
10862       TREE_SIDE_EFFECTS (patch) = 1;
10863     }
10864
10865   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10866      put it as the first expression of a COMPOUND_EXPR. The second
10867      expression being an empty statement to be later patched if
10868      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10869      the VALUE is the compound) in a hashtable and return a
10870      COMPOUND_EXPR built so that the result of the evaluation of the
10871      original PATCH node is returned. */
10872   if (STATIC_CLASS_INIT_OPT_P ()
10873       && current_function_decl && METHOD_STATIC (method))
10874     {
10875       tree list;
10876       tree fndecl = current_function_decl;
10877       /* We have to call force_evaluation_order now because creating a
10878          COMPOUND_EXPR wraps the arg list in a way that makes it
10879          unrecognizable by force_evaluation_order later.  Yuk.  */
10880       tree save = save_expr (force_evaluation_order (patch));
10881       tree type = TREE_TYPE (patch);
10882
10883       patch = build (COMPOUND_EXPR, type, save, empty_stmt_node);
10884       list = tree_cons (method, patch,
10885                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10886
10887       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10888
10889       patch = build (COMPOUND_EXPR, type, patch, save);
10890     }
10891
10892   return patch;
10893 }
10894
10895 static int
10896 invocation_mode (tree method, int super)
10897 {
10898   int access = get_access_flags_from_decl (method);
10899
10900   if (super)
10901     return INVOKE_SUPER;
10902
10903   if (access & ACC_STATIC)
10904     return INVOKE_STATIC;
10905
10906   /* We have to look for a constructor before we handle nonvirtual
10907      calls; otherwise the constructor will look nonvirtual.  */
10908   if (DECL_CONSTRUCTOR_P (method))
10909     return INVOKE_STATIC;
10910
10911   if (access & ACC_FINAL || access & ACC_PRIVATE)
10912     return INVOKE_NONVIRTUAL;
10913
10914   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10915     return INVOKE_NONVIRTUAL;
10916
10917   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10918     return INVOKE_INTERFACE;
10919
10920   return INVOKE_VIRTUAL;
10921 }
10922
10923 /* Retrieve a refined list of matching methods. It covers the step
10924    15.11.2 (Compile-Time Step 2) */
10925
10926 static tree
10927 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
10928 {
10929   tree atl = end_params_node;           /* Arg Type List */
10930   tree method, signature, list, node;
10931   const char *candidates;               /* Used for error report */
10932   char *dup;
10933
10934   /* Fix the arguments */
10935   for (node = arg_list; node; node = TREE_CHAIN (node))
10936     {
10937       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10938       /* Non primitive type may have to be resolved */
10939       if (!JPRIMITIVE_TYPE_P (current_arg))
10940         resolve_and_layout (current_arg, NULL_TREE);
10941       /* And promoted */
10942       if (TREE_CODE (current_arg) == RECORD_TYPE)
10943         current_arg = promote_type (current_arg);
10944       atl = tree_cons (NULL_TREE, current_arg, atl);
10945     }
10946
10947   /* Presto. If we're dealing with an anonymous class and a
10948      constructor call, generate the right constructor now, since we
10949      know the arguments' types. */
10950
10951   if (lc && ANONYMOUS_CLASS_P (class))
10952     {
10953       tree saved_current_class;
10954       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10955       saved_current_class = current_class;
10956       current_class = class;
10957       fix_constructors (mdecl);
10958       current_class = saved_current_class;
10959     }
10960
10961   /* Find all candidates and then refine the list, searching for the
10962      most specific method. */
10963   list = find_applicable_accessible_methods_list (lc, class, name, atl);
10964   list = find_most_specific_methods_list (list);
10965   if (list && !TREE_CHAIN (list))
10966     return TREE_VALUE (list);
10967
10968   /* Issue an error. List candidates if any. Candidates are listed
10969      only if accessible (non accessible methods may end-up here for
10970      the sake of a better error report). */
10971   candidates = NULL;
10972   if (list)
10973     {
10974       tree current;
10975       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
10976       for (current = list; current; current = TREE_CHAIN (current))
10977         {
10978           tree cm = TREE_VALUE (current);
10979           char string [4096];
10980           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
10981             continue;
10982           sprintf
10983             (string, "  `%s' in `%s'%s",
10984              get_printable_method_name (cm),
10985              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
10986              (TREE_CHAIN (current) ? "\n" : ""));
10987           obstack_grow (&temporary_obstack, string, strlen (string));
10988         }
10989       obstack_1grow (&temporary_obstack, '\0');
10990       candidates = obstack_finish (&temporary_obstack);
10991     }
10992   /* Issue the error message */
10993   method = make_node (FUNCTION_TYPE);
10994   TYPE_ARG_TYPES (method) = atl;
10995   signature = build_java_argument_signature (method);
10996   dup = xstrdup (lang_printable_name (class, 0));
10997   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
10998                        (lc ? "constructor" : "method"),
10999                        (lc ? dup : IDENTIFIER_POINTER (name)),
11000                        IDENTIFIER_POINTER (signature), dup,
11001                        (candidates ? candidates : ""));
11002   free (dup);
11003   return NULL_TREE;
11004 }
11005
11006 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
11007    when we're looking for a constructor. */
11008
11009 static tree
11010 find_applicable_accessible_methods_list (int lc, tree class, tree name,
11011                                          tree arglist)
11012 {
11013   static htab_t searched_classes;
11014   static int search_not_done = 0;
11015   tree list = NULL_TREE, all_list = NULL_TREE;
11016
11017   /* Check the hash table to determine if this class has been searched
11018      already. */
11019   if (searched_classes)
11020     {
11021       if (htab_find (searched_classes, class) != NULL)
11022         return NULL;
11023     }
11024   else
11025     {
11026       searched_classes = htab_create (10, htab_hash_pointer,
11027                                       htab_eq_pointer, NULL);
11028     }
11029
11030   search_not_done++;
11031   *htab_find_slot (searched_classes, class, INSERT) = class;
11032
11033   if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
11034     {
11035       load_class (class, 1);
11036       safe_layout_class (class);
11037     }
11038
11039   /* Search interfaces */
11040   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11041       && CLASS_INTERFACE (TYPE_NAME (class)))
11042     {
11043       int i, n;
11044       tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11045       search_applicable_methods_list (lc, TYPE_METHODS (class),
11046                                       name, arglist, &list, &all_list);
11047       n = TREE_VEC_LENGTH (basetype_vec);
11048       for (i = 1; i < n; i++)
11049         {
11050           tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11051           tree rlist;
11052
11053           rlist = find_applicable_accessible_methods_list (lc,  t, name,
11054                                                            arglist);
11055           list = chainon (rlist, list);
11056         }
11057     }
11058   /* Search classes */
11059   else
11060     {
11061       search_applicable_methods_list (lc, TYPE_METHODS (class),
11062                                       name, arglist, &list, &all_list);
11063
11064       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11065          that we only search in class. Note that we should have found
11066          something at this point. */
11067       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11068         {
11069           lc = 1;
11070           if (!list)
11071             abort ();
11072         }
11073
11074       /* We must search all interfaces of this class */
11075       if (!lc)
11076       {
11077         tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11078         int n = TREE_VEC_LENGTH (basetype_vec), i;
11079         for (i = 1; i < n; i++)
11080           {
11081             tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11082             if (t != object_type_node)
11083               {
11084                 tree rlist
11085                   = find_applicable_accessible_methods_list (lc, t,
11086                                                              name, arglist);
11087                 list = chainon (rlist, list);
11088               }
11089           }
11090       }
11091
11092       /* Search superclass */
11093       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11094         {
11095           tree rlist;
11096           class = CLASSTYPE_SUPER (class);
11097           rlist = find_applicable_accessible_methods_list (lc, class,
11098                                                            name, arglist);
11099           list = chainon (rlist, list);
11100         }
11101     }
11102
11103   search_not_done--;
11104
11105   /* We're done. Reset the searched classes list and finally search
11106      java.lang.Object if it wasn't searched already. */
11107   if (!search_not_done)
11108     {
11109       if (!lc
11110           && TYPE_METHODS (object_type_node)
11111           && htab_find (searched_classes, object_type_node) == NULL)
11112         {
11113           search_applicable_methods_list (lc,
11114                                           TYPE_METHODS (object_type_node),
11115                                           name, arglist, &list, &all_list);
11116         }
11117       htab_delete (searched_classes);
11118       searched_classes = NULL;
11119     }
11120
11121   /* Either return the list obtained or all selected (but
11122      inaccessible) methods for better error report. */
11123   return (!list ? all_list : list);
11124 }
11125
11126 /* Effectively search for the appropriate method in method */
11127
11128 static void
11129 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11130                                 tree *list, tree *all_list)
11131 {
11132   for (; method; method = TREE_CHAIN (method))
11133     {
11134       /* When dealing with constructor, stop here, otherwise search
11135          other classes */
11136       if (lc && !DECL_CONSTRUCTOR_P (method))
11137         continue;
11138       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11139                        || (DECL_NAME (method) != name)))
11140         continue;
11141
11142       if (argument_types_convertible (method, arglist))
11143         {
11144           /* Retain accessible methods only */
11145           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11146                                  method, NULL_TREE, 0))
11147             *list = tree_cons (NULL_TREE, method, *list);
11148           else
11149             /* Also retain all selected method here */
11150             *all_list = tree_cons (NULL_TREE, method, *list);
11151         }
11152     }
11153 }
11154
11155 /* 15.11.2.2 Choose the Most Specific Method */
11156
11157 static tree
11158 find_most_specific_methods_list (tree list)
11159 {
11160   int max = 0;
11161   int abstract, candidates;
11162   tree current, new_list = NULL_TREE;
11163   for (current = list; current; current = TREE_CHAIN (current))
11164     {
11165       tree method;
11166       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11167
11168       for (method = list; method; method = TREE_CHAIN (method))
11169         {
11170           tree method_v, current_v;
11171           /* Don't test a method against itself */
11172           if (method == current)
11173             continue;
11174
11175           method_v = TREE_VALUE (method);
11176           current_v = TREE_VALUE (current);
11177
11178           /* Compare arguments and location where methods where declared */
11179           if (argument_types_convertible (method_v, current_v))
11180             {
11181               if (valid_method_invocation_conversion_p
11182                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11183                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11184                       && enclosing_context_p (DECL_CONTEXT (method_v),
11185                                               DECL_CONTEXT (current_v))))
11186                 {
11187                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
11188                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11189                   max = (v > max ? v : max);
11190                 }
11191             }
11192         }
11193     }
11194
11195   /* Review the list and select the maximally specific methods */
11196   for (current = list, abstract = -1, candidates = -1;
11197        current; current = TREE_CHAIN (current))
11198     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11199       {
11200         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11201         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11202         candidates++;
11203       }
11204
11205   /* If we have several and they're all abstract, just pick the
11206      closest one. */
11207   if (candidates > 0 && candidates == abstract)
11208     {
11209       /* FIXME: merge the throws clauses.  There is no convenient way
11210          to do this in gcj right now, since ideally we'd like to
11211          introduce a new METHOD_DECL here, but that is really not
11212          possible.  */
11213       new_list = nreverse (new_list);
11214       TREE_CHAIN (new_list) = NULL_TREE;
11215       return new_list;
11216     }
11217
11218   /* We have several (we couldn't find a most specific), all but one
11219      are abstract, we pick the only non abstract one. */
11220   if (candidates > 0 && (candidates == abstract+1))
11221     {
11222       for (current = new_list; current; current = TREE_CHAIN (current))
11223         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11224           {
11225             TREE_CHAIN (current) = NULL_TREE;
11226             new_list = current;
11227           }
11228     }
11229
11230   /* If we can't find one, lower expectations and try to gather multiple
11231      maximally specific methods */
11232   while (!new_list && max)
11233     {
11234       while (--max > 0)
11235         {
11236           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11237             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11238         }
11239     }
11240
11241   return new_list;
11242 }
11243
11244 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11245    converted by method invocation conversion (5.3) to the type of the
11246    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11247    to change less often than M1. */
11248
11249 static GTY(()) tree m2_arg_value;
11250 static GTY(()) tree m2_arg_cache;
11251
11252 static int
11253 argument_types_convertible (tree m1, tree m2_or_arglist)
11254 {
11255   register tree m1_arg, m2_arg;
11256
11257   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11258
11259   if (m2_arg_value == m2_or_arglist)
11260     m2_arg = m2_arg_cache;
11261   else
11262     {
11263       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11264          argument types */
11265       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11266         {
11267           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11268           if (!METHOD_STATIC (m2_or_arglist))
11269             m2_arg = TREE_CHAIN (m2_arg);
11270         }
11271       else
11272         m2_arg = m2_or_arglist;
11273
11274       m2_arg_value = m2_or_arglist;
11275       m2_arg_cache = m2_arg;
11276     }
11277
11278   while (m1_arg != end_params_node && m2_arg != end_params_node)
11279     {
11280       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11281       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11282                                                  TREE_VALUE (m2_arg)))
11283         break;
11284       m1_arg = TREE_CHAIN (m1_arg);
11285       m2_arg = TREE_CHAIN (m2_arg);
11286     }
11287   return m1_arg == end_params_node && m2_arg == end_params_node;
11288 }
11289
11290 /* Qualification routines */
11291
11292 static void
11293 qualify_ambiguous_name (tree id)
11294 {
11295   tree qual, qual_wfl, name = NULL_TREE, decl, ptr_type = NULL_TREE,
11296     saved_current_class;
11297   int again, super_found = 0, this_found = 0, new_array_found = 0;
11298   int code;
11299
11300   /* We first qualify the first element, then derive qualification of
11301      others based on the first one. If the first element is qualified
11302      by a resolution (field or type), this resolution is stored in the
11303      QUAL_RESOLUTION of the qual element being examined. We need to
11304      save the current_class since the use of SUPER might change the
11305      its value. */
11306   saved_current_class = current_class;
11307   qual = EXPR_WFL_QUALIFICATION (id);
11308   do {
11309
11310     /* Simple qualified expression feature a qual_wfl that is a
11311        WFL. Expression derived from a primary feature more complicated
11312        things like a CALL_EXPR. Expression from primary need to be
11313        worked out to extract the part on which the qualification will
11314        take place. */
11315     qual_wfl = QUAL_WFL (qual);
11316     switch (TREE_CODE (qual_wfl))
11317       {
11318       case CALL_EXPR:
11319         qual_wfl = TREE_OPERAND (qual_wfl, 0);
11320         if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION
11321             || (EXPR_WFL_QUALIFICATION (qual_wfl)
11322                 && TREE_CODE (EXPR_WFL_QUALIFICATION (qual_wfl)) == TREE_LIST))
11323           {
11324             qual = EXPR_WFL_QUALIFICATION (qual_wfl);
11325             qual_wfl = QUAL_WFL (qual);
11326           }
11327         break;
11328       case NEW_ARRAY_EXPR:
11329       case NEW_ANONYMOUS_ARRAY_EXPR:
11330         qual = TREE_CHAIN (qual);
11331         again = new_array_found = 1;
11332         continue;
11333       case CONVERT_EXPR:
11334         break;
11335       case NEW_CLASS_EXPR:
11336         qual_wfl = TREE_OPERAND (qual_wfl, 0);
11337         break;
11338       case ARRAY_REF:
11339         while (TREE_CODE (qual_wfl) == ARRAY_REF)
11340           qual_wfl = TREE_OPERAND (qual_wfl, 0);
11341         break;
11342       case STRING_CST:
11343         qual = TREE_CHAIN (qual);
11344         qual_wfl = QUAL_WFL (qual);
11345         break;
11346       case CLASS_LITERAL:
11347         qual = TREE_CHAIN (qual);
11348         qual_wfl = QUAL_WFL (qual);
11349       break;
11350       default:
11351         /* Fix for -Wall. Just break doing nothing */
11352         break;
11353       }
11354
11355     ptr_type = current_class;
11356     again = 0;
11357     code = TREE_CODE (qual_wfl);
11358
11359     /* Pos evaluation: non WFL leading expression nodes */
11360     if (code == CONVERT_EXPR
11361         && TREE_CODE (TREE_TYPE (qual_wfl)) == EXPR_WITH_FILE_LOCATION)
11362       name = EXPR_WFL_NODE (TREE_TYPE (qual_wfl));
11363
11364     else if (code == INTEGER_CST)
11365       name = qual_wfl;
11366
11367     else if (code == CONVERT_EXPR &&
11368              TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
11369       name = TREE_OPERAND (qual_wfl, 0);
11370
11371     else if (code == CONVERT_EXPR
11372              && TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == CALL_EXPR
11373              && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (qual_wfl, 0), 0))
11374                  == EXPR_WITH_FILE_LOCATION))
11375       name = TREE_OPERAND (TREE_OPERAND (qual_wfl, 0), 0);
11376
11377     else if ((code == ARRAY_REF || code == CALL_EXPR || code == MODIFY_EXPR) &&
11378              TREE_CODE (TREE_OPERAND (qual_wfl, 0)) == EXPR_WITH_FILE_LOCATION)
11379       name = EXPR_WFL_NODE (TREE_OPERAND (qual_wfl, 0));
11380
11381     else if (code == TREE_LIST)
11382       name = EXPR_WFL_NODE (TREE_PURPOSE (qual_wfl));
11383
11384     else if (code == STRING_CST || code == CONDITIONAL_EXPR
11385              || code == PLUS_EXPR)
11386       {
11387         qual = TREE_CHAIN (qual);
11388         qual_wfl = QUAL_WFL (qual);
11389         again = 1;
11390       }
11391     else
11392       {
11393         name = EXPR_WFL_NODE (qual_wfl);
11394         if (!name)
11395           {
11396             qual = EXPR_WFL_QUALIFICATION (qual_wfl);
11397             again = 1;
11398           }
11399       }
11400
11401     /* If we have a THIS (from a primary), we set the context accordingly */
11402     if (name == this_identifier_node)
11403       {
11404         /* This isn't really elegant. One more added irregularity
11405            before I start using COMPONENT_REF (hopefully very soon.)  */
11406         if (TREE_CODE (TREE_PURPOSE (qual)) == ARRAY_REF
11407             && TREE_CODE (TREE_OPERAND (TREE_PURPOSE (qual), 0)) ==
11408                EXPR_WITH_FILE_LOCATION
11409             && EXPR_WFL_NODE (TREE_OPERAND (TREE_PURPOSE (qual), 0)) ==
11410                this_identifier_node)
11411             {
11412               qual = TREE_OPERAND (TREE_PURPOSE (qual), 0);
11413               qual = EXPR_WFL_QUALIFICATION (qual);
11414             }
11415         qual = TREE_CHAIN (qual);
11416         qual_wfl = QUAL_WFL (qual);
11417         if (TREE_CODE (qual_wfl) == CALL_EXPR)
11418           again = 1;
11419         else if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION)
11420           name = EXPR_WFL_NODE (qual_wfl);
11421         else if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR)
11422           name = TREE_OPERAND (qual_wfl, 0);
11423         this_found = 1;
11424       }
11425     /* If we have a SUPER, we set the context accordingly */
11426     if (name == super_identifier_node)
11427       {
11428         current_class = CLASSTYPE_SUPER (ptr_type);
11429         /* Check that there is such a thing as a super class. If not,
11430            return.  The error will be caught later on, during the
11431            resolution */
11432         if (!current_class)
11433           {
11434             current_class = saved_current_class;
11435             return;
11436           }
11437         qual = TREE_CHAIN (qual);
11438         /* Do one more interation to set things up */
11439         super_found = again = 1;
11440       }
11441   } while (again);
11442
11443   /* If name appears within the scope of a local variable declaration
11444      or parameter declaration, then it is an expression name. We don't
11445      carry this test out if we're in the context of the use of SUPER
11446      or THIS */
11447   if (!this_found && !super_found
11448       && TREE_CODE (name) != STRING_CST && TREE_CODE (name) != INTEGER_CST
11449       && (decl = IDENTIFIER_LOCAL_VALUE (name)))
11450     {
11451       RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
11452       QUAL_RESOLUTION (qual) = decl;
11453     }
11454
11455   /* If within the class/interface NAME was found to be used there
11456      exists a (possibly inherited) field named NAME, then this is an
11457      expression name. If we saw a NEW_ARRAY_EXPR before and want to
11458      address length, it is OK. */
11459   else if ((decl = lookup_field_wrapper (ptr_type, name))
11460            || name == length_identifier_node)
11461     {
11462       RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
11463       QUAL_RESOLUTION (qual) = (new_array_found ? NULL_TREE : decl);
11464     }
11465
11466   /* We reclassify NAME as yielding to a type name resolution if:
11467      - NAME is a class/interface declared within the compilation
11468        unit containing NAME,
11469      - NAME is imported via a single-type-import declaration,
11470      - NAME is declared in an another compilation unit of the package
11471        of the compilation unit containing NAME,
11472      - NAME is declared by exactly on type-import-on-demand declaration
11473      of the compilation unit containing NAME.
11474      - NAME is actually a STRING_CST.
11475      This can't happen if the expression was qualified by `this.' */
11476   else if (! this_found &&
11477            (TREE_CODE (name) == STRING_CST ||
11478             TREE_CODE (name) == INTEGER_CST ||
11479             (decl = resolve_and_layout (name, NULL_TREE))))
11480     {
11481       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11482       QUAL_RESOLUTION (qual) = decl;
11483     }
11484
11485   /* Method call, array references and cast are expression name */
11486   else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR
11487            || TREE_CODE (QUAL_WFL (qual)) == ARRAY_REF
11488            || TREE_CODE (QUAL_WFL (qual)) == CONVERT_EXPR
11489            || TREE_CODE (QUAL_WFL (qual)) == MODIFY_EXPR)
11490     RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
11491
11492   /* Check here that NAME isn't declared by more than one
11493      type-import-on-demand declaration of the compilation unit
11494      containing NAME. FIXME */
11495
11496   /* Otherwise, NAME is reclassified as a package name */
11497   else
11498     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11499
11500   /* Propagate the qualification accross other components of the
11501      qualified name */
11502   for (qual = TREE_CHAIN (qual); qual;
11503        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11504     {
11505       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11506         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11507       else
11508         RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (qual)) = 1;
11509     }
11510
11511   /* Store the global qualification for the ambiguous part of ID back
11512      into ID fields */
11513   if (RESOLVE_EXPRESSION_NAME_P (qual_wfl))
11514     RESOLVE_EXPRESSION_NAME_P (id) = 1;
11515   else if (RESOLVE_TYPE_NAME_P (qual_wfl))
11516     RESOLVE_TYPE_NAME_P (id) = 1;
11517   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11518     RESOLVE_PACKAGE_NAME_P (id) = 1;
11519
11520   /* Restore the current class */
11521   current_class = saved_current_class;
11522 }
11523
11524 static int
11525 breakdown_qualified (tree *left, tree *right, tree source)
11526 {
11527   char *p, *base;
11528   int l = IDENTIFIER_LENGTH (source);
11529
11530   base = alloca (l + 1);
11531   memcpy (base, IDENTIFIER_POINTER (source), l + 1);
11532
11533   /* Breakdown NAME into REMAINDER . IDENTIFIER.  */
11534   p = base + l - 1;
11535   while (*p != '.' && p != base)
11536     p--;
11537
11538   /* We didn't find a '.'. Return an error.  */
11539   if (p == base)
11540     return 1;
11541
11542   *p = '\0';
11543   if (right)
11544     *right = get_identifier (p+1);
11545   *left = get_identifier (base);
11546
11547   return 0;
11548 }
11549
11550 /* Return TRUE if two classes are from the same package. */
11551
11552 static int
11553 in_same_package (tree name1, tree name2)
11554 {
11555   tree tmp;
11556   tree pkg1;
11557   tree pkg2;
11558
11559   if (TREE_CODE (name1) == TYPE_DECL)
11560     name1 = DECL_NAME (name1);
11561   if (TREE_CODE (name2) == TYPE_DECL)
11562     name2 = DECL_NAME (name2);
11563
11564   if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
11565     /* One in empty package. */
11566     return 0;
11567
11568   if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
11569     /* Both in empty package. */
11570     return 1;
11571
11572   breakdown_qualified (&pkg1, &tmp, name1);
11573   breakdown_qualified (&pkg2, &tmp, name2);
11574
11575   return (pkg1 == pkg2);
11576 }
11577
11578 /* Patch tree nodes in a function body. When a BLOCK is found, push
11579    local variable decls if present.
11580    Same as java_complete_lhs, but does resolve static finals to values. */
11581
11582 static tree
11583 java_complete_tree (tree node)
11584 {
11585   node = java_complete_lhs (node);
11586   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11587       && DECL_INITIAL (node) != NULL_TREE
11588       && !flag_emit_xref)
11589     {
11590       tree value = fold_constant_for_init (node, node);
11591       if (value != NULL_TREE)
11592         return value;
11593     }
11594   return node;
11595 }
11596
11597 static tree
11598 java_stabilize_reference (tree node)
11599 {
11600   if (TREE_CODE (node) == COMPOUND_EXPR)
11601     {
11602       tree op0 = TREE_OPERAND (node, 0);
11603       tree op1 = TREE_OPERAND (node, 1);
11604       TREE_OPERAND (node, 0) = save_expr (op0);
11605       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11606       return node;
11607     }
11608   return stabilize_reference (node);
11609 }
11610
11611 /* Patch tree nodes in a function body. When a BLOCK is found, push
11612    local variable decls if present.
11613    Same as java_complete_tree, but does not resolve static finals to values. */
11614
11615 static tree
11616 java_complete_lhs (tree node)
11617 {
11618   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11619   int flag;
11620
11621   /* CONVERT_EXPR always has its type set, even though it needs to be
11622      worked out. */
11623   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11624     return node;
11625
11626   /* The switch block implements cases processing container nodes
11627      first.  Contained nodes are always written back. Leaves come
11628      next and return a value. */
11629   switch (TREE_CODE (node))
11630     {
11631     case BLOCK:
11632
11633       /* 1- Block section.
11634          Set the local values on decl names so we can identify them
11635          faster when they're referenced. At that stage, identifiers
11636          are legal so we don't check for declaration errors. */
11637       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11638         {
11639           DECL_CONTEXT (cn) = current_function_decl;
11640           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11641         }
11642       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11643           CAN_COMPLETE_NORMALLY (node) = 1;
11644       else
11645         {
11646           tree stmt = BLOCK_EXPR_BODY (node);
11647           tree *ptr;
11648           int error_seen = 0;
11649           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11650             {
11651               /* Re-order from (((A; B); C); ...; Z) to
11652                  (A; (B; (C ; (...; Z)))).
11653                  This makes it easier to scan the statements left-to-right
11654                  without using recursion (which might overflow the stack
11655                  if the block has many statements. */
11656               for (;;)
11657                 {
11658                   tree left = TREE_OPERAND (stmt, 0);
11659                   if (TREE_CODE (left) != COMPOUND_EXPR)
11660                     break;
11661                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11662                   TREE_OPERAND (left, 1) = stmt;
11663                   stmt = left;
11664                 }
11665               BLOCK_EXPR_BODY (node) = stmt;
11666             }
11667
11668           /* Now do the actual complete, without deep recursion for
11669              long blocks. */
11670           ptr = &BLOCK_EXPR_BODY (node);
11671           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11672                  && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
11673             {
11674               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11675               tree *next = &TREE_OPERAND (*ptr, 1);
11676               TREE_OPERAND (*ptr, 0) = cur;
11677               if (cur == empty_stmt_node)
11678                 {
11679                   /* Optimization;  makes it easier to detect empty bodies.
11680                      Most useful for <clinit> with all-constant initializer. */
11681                   *ptr = *next;
11682                   continue;
11683                 }
11684               if (TREE_CODE (cur) == ERROR_MARK)
11685                 error_seen++;
11686               else if (! CAN_COMPLETE_NORMALLY (cur))
11687                 {
11688                   wfl_op2 = *next;
11689                   for (;;)
11690                     {
11691                       if (TREE_CODE (wfl_op2) == BLOCK)
11692                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11693                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11694                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11695                       else
11696                         break;
11697                     }
11698                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11699                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11700                     unreachable_stmt_error (*ptr);
11701                 }
11702               if (TREE_TYPE (*ptr) == NULL_TREE)
11703                 TREE_TYPE (*ptr) = void_type_node;
11704               ptr = next;
11705             }
11706           *ptr = java_complete_tree (*ptr);
11707
11708           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11709             return error_mark_node;
11710           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11711         }
11712       /* Turn local bindings to null */
11713       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11714         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11715
11716       TREE_TYPE (node) = void_type_node;
11717       break;
11718
11719       /* 2- They are expressions but ultimately deal with statements */
11720
11721     case THROW_EXPR:
11722       wfl_op1 = TREE_OPERAND (node, 0);
11723       COMPLETE_CHECK_OP_0 (node);
11724       /* 14.19 A throw statement cannot complete normally. */
11725       CAN_COMPLETE_NORMALLY (node) = 0;
11726       return patch_throw_statement (node, wfl_op1);
11727
11728     case SYNCHRONIZED_EXPR:
11729       wfl_op1 = TREE_OPERAND (node, 0);
11730       return patch_synchronized_statement (node, wfl_op1);
11731
11732     case TRY_EXPR:
11733       return patch_try_statement (node);
11734
11735     case TRY_FINALLY_EXPR:
11736       COMPLETE_CHECK_OP_0 (node);
11737       COMPLETE_CHECK_OP_1 (node);
11738       if (TREE_OPERAND (node, 0) == empty_stmt_node)
11739         return TREE_OPERAND (node, 1);
11740       if (TREE_OPERAND (node, 1) == empty_stmt_node)
11741         return TREE_OPERAND (node, 0);
11742       CAN_COMPLETE_NORMALLY (node)
11743         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11744            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11745       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11746       return node;
11747
11748     case LABELED_BLOCK_EXPR:
11749       PUSH_LABELED_BLOCK (node);
11750       if (LABELED_BLOCK_BODY (node))
11751         COMPLETE_CHECK_OP_1 (node);
11752       TREE_TYPE (node) = void_type_node;
11753       POP_LABELED_BLOCK ();
11754
11755       if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
11756         {
11757           LABELED_BLOCK_BODY (node) = NULL_TREE;
11758           CAN_COMPLETE_NORMALLY (node) = 1;
11759         }
11760       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11761         CAN_COMPLETE_NORMALLY (node) = 1;
11762       return node;
11763
11764     case EXIT_BLOCK_EXPR:
11765       /* We don't complete operand 1, because it's the return value of
11766          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11767       return patch_bc_statement (node);
11768
11769     case CASE_EXPR:
11770       cn = java_complete_tree (TREE_OPERAND (node, 0));
11771       if (cn == error_mark_node)
11772         return cn;
11773
11774       /* First, the case expression must be constant. Values of final
11775          fields are accepted. */
11776       cn = fold (cn);
11777       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11778           && JDECL_P (TREE_OPERAND (cn, 1))
11779           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11780           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11781         {
11782           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11783                                        TREE_OPERAND (cn, 1));
11784         }
11785       /* Accept final locals too. */
11786       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn))
11787         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11788
11789       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11790         {
11791           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11792           parse_error_context (node, "Constant expression required");
11793           return error_mark_node;
11794         }
11795
11796       nn = ctxp->current_loop;
11797
11798       /* It must be assignable to the type of the switch expression. */
11799       if (!try_builtin_assignconv (NULL_TREE,
11800                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11801         {
11802           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11803           parse_error_context
11804             (wfl_operator,
11805              "Incompatible type for case. Can't convert `%s' to `int'",
11806              lang_printable_name (TREE_TYPE (cn), 0));
11807           return error_mark_node;
11808         }
11809
11810       cn = fold (convert (int_type_node, cn));
11811       TREE_CONSTANT_OVERFLOW (cn) = 0;
11812       CAN_COMPLETE_NORMALLY (cn) = 1;
11813
11814       /* Save the label on a list so that we can later check for
11815          duplicates.  */
11816       case_label_list = tree_cons (node, cn, case_label_list);
11817
11818       /* Multiple instance of a case label bearing the same value is
11819          checked later. The case expression is all right so far. */
11820       if (TREE_CODE (cn) == VAR_DECL)
11821         cn = DECL_INITIAL (cn);
11822       TREE_OPERAND (node, 0) = cn;
11823       TREE_TYPE (node) = void_type_node;
11824       CAN_COMPLETE_NORMALLY (node) = 1;
11825       TREE_SIDE_EFFECTS (node) = 1;
11826       break;
11827
11828     case DEFAULT_EXPR:
11829       nn = ctxp->current_loop;
11830       /* Only one default label is allowed per switch statement */
11831       if (SWITCH_HAS_DEFAULT (nn))
11832         {
11833           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11834           parse_error_context (wfl_operator,
11835                                "Duplicate case label: `default'");
11836           return error_mark_node;
11837         }
11838       else
11839         SWITCH_HAS_DEFAULT (nn) = 1;
11840       TREE_TYPE (node) = void_type_node;
11841       TREE_SIDE_EFFECTS (node) = 1;
11842       CAN_COMPLETE_NORMALLY (node) = 1;
11843       break;
11844
11845     case SWITCH_EXPR:
11846     case LOOP_EXPR:
11847       PUSH_LOOP (node);
11848       /* Check whether the loop was enclosed in a labeled
11849          statement. If not, create one, insert the loop in it and
11850          return the node */
11851       nn = patch_loop_statement (node);
11852
11853       /* Anyways, walk the body of the loop */
11854       if (TREE_CODE (node) == LOOP_EXPR)
11855         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11856       /* Switch statement: walk the switch expression and the cases */
11857       else
11858         node = patch_switch_statement (node);
11859
11860       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11861         nn = error_mark_node;
11862       else
11863         {
11864           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11865           /* If we returned something different, that's because we
11866              inserted a label. Pop the label too. */
11867           if (nn != node)
11868             {
11869               if (CAN_COMPLETE_NORMALLY (node))
11870                 CAN_COMPLETE_NORMALLY (nn) = 1;
11871               POP_LABELED_BLOCK ();
11872             }
11873         }
11874       POP_LOOP ();
11875       return nn;
11876
11877     case EXIT_EXPR:
11878       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11879       return patch_exit_expr (node);
11880
11881     case COND_EXPR:
11882       /* Condition */
11883       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11884       if (TREE_OPERAND (node, 0) == error_mark_node)
11885         return error_mark_node;
11886       /* then-else branches */
11887       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11888       if (TREE_OPERAND (node, 1) == error_mark_node)
11889         return error_mark_node;
11890       TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11891       if (TREE_OPERAND (node, 2) == error_mark_node)
11892         return error_mark_node;
11893       return patch_if_else_statement (node);
11894       break;
11895
11896     case CONDITIONAL_EXPR:
11897       /* Condition */
11898       wfl_op1 = TREE_OPERAND (node, 0);
11899       COMPLETE_CHECK_OP_0 (node);
11900       wfl_op2 = TREE_OPERAND (node, 1);
11901       COMPLETE_CHECK_OP_1 (node);
11902       wfl_op3 = TREE_OPERAND (node, 2);
11903       COMPLETE_CHECK_OP_2 (node);
11904       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11905
11906       /* 3- Expression section */
11907     case COMPOUND_EXPR:
11908       wfl_op2 = TREE_OPERAND (node, 1);
11909       TREE_OPERAND (node, 0) = nn =
11910         java_complete_tree (TREE_OPERAND (node, 0));
11911       if (wfl_op2 == empty_stmt_node)
11912         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11913       else
11914         {
11915           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11916             {
11917               /* An unreachable condition in a do-while statement
11918                  is *not* (technically) an unreachable statement. */
11919               nn = wfl_op2;
11920               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11921                 nn = EXPR_WFL_NODE (nn);
11922               /* NN can be NULL_TREE exactly when UPDATE is, in
11923                  finish_for_loop.  */
11924               if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11925                 {
11926                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11927                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11928                     {
11929                       /* Perhaps this warning should have an
11930                          associated flag.  The code being compiled is
11931                          pedantically correct, but useless.  */
11932                       parse_warning_context (wfl_operator,
11933                                              "Unreachable statement");
11934                     }
11935                   else
11936                     parse_error_context (wfl_operator,
11937                                          "Unreachable statement");
11938                 }
11939             }
11940           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11941           if (TREE_OPERAND (node, 1) == error_mark_node)
11942             return error_mark_node;
11943           /* Even though we might allow the case where the first
11944              operand doesn't return normally, we still should compute
11945              CAN_COMPLETE_NORMALLY correctly.  */
11946           CAN_COMPLETE_NORMALLY (node)
11947             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11948                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11949         }
11950       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11951       break;
11952
11953     case RETURN_EXPR:
11954       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11955       return patch_return (node);
11956
11957     case EXPR_WITH_FILE_LOCATION:
11958       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11959           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11960         {
11961           tree wfl = node;
11962           node = resolve_expression_name (node, NULL);
11963           if (node == error_mark_node)
11964             return node;
11965           /* Keep line number information somewhere were it doesn't
11966              disrupt the completion process. */
11967           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11968             {
11969               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11970               TREE_OPERAND (node, 1) = wfl;
11971             }
11972           CAN_COMPLETE_NORMALLY (node) = 1;
11973         }
11974       else
11975         {
11976           tree body;
11977           int save_lineno = input_line;
11978           input_line = EXPR_WFL_LINENO (node);
11979           body = java_complete_tree (EXPR_WFL_NODE (node));
11980           input_line = save_lineno;
11981           EXPR_WFL_NODE (node) = body;
11982           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11983           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11984           if (body == empty_stmt_node || TREE_CONSTANT (body))
11985             {
11986               /* Makes it easier to constant fold, detect empty bodies. */
11987               return body;
11988             }
11989           if (body == error_mark_node)
11990             {
11991               /* Its important for the evaluation of assignment that
11992                  this mark on the TREE_TYPE is propagated. */
11993               TREE_TYPE (node) = error_mark_node;
11994               return error_mark_node;
11995             }
11996           else
11997             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11998
11999         }
12000       break;
12001
12002     case NEW_ARRAY_EXPR:
12003       /* Patch all the dimensions */
12004       flag = 0;
12005       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12006         {
12007           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
12008           tree dim = convert (int_type_node,
12009                               java_complete_tree (TREE_VALUE (cn)));
12010           if (dim == error_mark_node)
12011             {
12012               flag = 1;
12013               continue;
12014             }
12015           else
12016             {
12017               TREE_VALUE (cn) = dim;
12018               /* Setup the location of the current dimension, for
12019                  later error report. */
12020               TREE_PURPOSE (cn) =
12021                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
12022               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
12023             }
12024         }
12025       /* They complete the array creation expression, if no errors
12026          were found. */
12027       CAN_COMPLETE_NORMALLY (node) = 1;
12028       return (flag ? error_mark_node
12029               : force_evaluation_order (patch_newarray (node)));
12030
12031     case NEW_ANONYMOUS_ARRAY_EXPR:
12032       /* Create the array type if necessary. */
12033       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
12034         {
12035           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
12036           if (!(type = resolve_type_during_patch (type)))
12037             return error_mark_node;
12038           type = build_array_from_name (type, NULL_TREE,
12039                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
12040           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
12041         }
12042       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
12043                                    ANONYMOUS_ARRAY_INITIALIZER (node));
12044       if (node == error_mark_node)
12045         return error_mark_node;
12046       CAN_COMPLETE_NORMALLY (node) = 1;
12047       return node;
12048
12049     case NEW_CLASS_EXPR:
12050     case CALL_EXPR:
12051       /* Complete function's argument(s) first */
12052       if (complete_function_arguments (node))
12053         return error_mark_node;
12054       else
12055         {
12056           tree decl, wfl = TREE_OPERAND (node, 0);
12057           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
12058           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
12059                            super_identifier_node);
12060           tree arguments;
12061
12062           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
12063                                           from_super, 0, &decl);
12064           if (node == error_mark_node)
12065             return error_mark_node;
12066
12067           if (TREE_CODE (node) == CALL_EXPR
12068               && TREE_OPERAND (node, 1) != NULL_TREE)
12069             arguments = TREE_VALUE (TREE_OPERAND (node, 1));
12070           else
12071             arguments = NULL_TREE;
12072           check_thrown_exceptions (EXPR_WFL_LINECOL (node), decl,
12073                                    arguments);
12074           /* If we call this(...), register signature and positions */
12075           if (in_this)
12076             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
12077               tree_cons (wfl, decl,
12078                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
12079           CAN_COMPLETE_NORMALLY (node) = 1;
12080           return force_evaluation_order (node);
12081         }
12082
12083     case MODIFY_EXPR:
12084       /* Save potential wfls */
12085       wfl_op1 = TREE_OPERAND (node, 0);
12086       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
12087
12088       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
12089           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
12090           && DECL_INITIAL (nn) != NULL_TREE)
12091         {
12092           tree value;
12093
12094           value = fold_constant_for_init (nn, nn);
12095
12096           /* When we have a primitype type, or a string and we're not
12097              emitting a class file, we actually don't want to generate
12098              anything for the assignment. */
12099           if (value != NULL_TREE &&
12100               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
12101                (TREE_TYPE (value) == string_ptr_type_node &&
12102                 ! flag_emit_class_files)))
12103             {
12104               /* Prepare node for patch_assignment */
12105               TREE_OPERAND (node, 1) = value;
12106               /* Call patch assignment to verify the assignment */
12107               if (patch_assignment (node, wfl_op1) == error_mark_node)
12108                 return error_mark_node;
12109               /* Set DECL_INITIAL properly (a conversion might have
12110                  been decided by patch_assignment) and return the
12111                  empty statement. */
12112               else
12113                 {
12114                   tree patched = patch_string (TREE_OPERAND (node, 1));
12115                   if (patched)
12116                     DECL_INITIAL (nn) = patched;
12117                   else
12118                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12119                   DECL_FIELD_FINAL_IUD (nn) = 1;
12120                   return empty_stmt_node;
12121                 }
12122             }
12123           if (! flag_emit_class_files)
12124             DECL_INITIAL (nn) = NULL_TREE;
12125         }
12126       wfl_op2 = TREE_OPERAND (node, 1);
12127
12128       if (TREE_OPERAND (node, 0) == error_mark_node)
12129         return error_mark_node;
12130
12131       flag = COMPOUND_ASSIGN_P (wfl_op2);
12132       if (flag)
12133         {
12134           /* This might break when accessing outer field from inner
12135              class. TESTME, FIXME */
12136           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
12137
12138           /* Hand stabilize the lhs on both places */
12139           TREE_OPERAND (node, 0) = lvalue;
12140           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
12141             (flag_emit_class_files ? lvalue : save_expr (lvalue));
12142
12143           /* 15.25.2.a: Left hand is not an array access. FIXME */
12144           /* Now complete the RHS. We write it back later on. */
12145           nn = java_complete_tree (TREE_OPERAND (node, 1));
12146
12147           if ((cn = patch_string (nn)))
12148             nn = cn;
12149
12150           /* The last part of the rewrite for E1 op= E2 is to have
12151              E1 = (T)(E1 op E2), with T being the type of E1. */
12152           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
12153                                                TREE_TYPE (lvalue), nn));
12154
12155           /* If the assignment is compound and has reference type,
12156              then ensure the LHS has type String and nothing else.  */
12157           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
12158               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
12159             parse_error_context (wfl_op2,
12160                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
12161                                  lang_printable_name (TREE_TYPE (lvalue), 0));
12162
12163           /* 15.25.2.b: Left hand is an array access. FIXME */
12164         }
12165
12166       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12167          function to complete this RHS. Note that a NEW_ARRAY_INIT
12168          might have been already fully expanded if created as a result
12169          of processing an anonymous array initializer. We avoid doing
12170          the operation twice by testing whether the node already bears
12171          a type. */
12172       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12173         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12174                                    TREE_OPERAND (node, 1));
12175       /* Otherwise we simply complete the RHS */
12176       else
12177         nn = java_complete_tree (TREE_OPERAND (node, 1));
12178
12179       if (nn == error_mark_node)
12180         return error_mark_node;
12181
12182       /* Write back the RHS as we evaluated it. */
12183       TREE_OPERAND (node, 1) = nn;
12184
12185       /* In case we're handling = with a String as a RHS, we need to
12186          produce a String out of the RHS (it might still be a
12187          STRING_CST or a StringBuffer at this stage */
12188       if ((nn = patch_string (TREE_OPERAND (node, 1))))
12189         TREE_OPERAND (node, 1) = nn;
12190
12191       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12192                                         TREE_OPERAND (node, 1))))
12193         {
12194           /* We return error_mark_node if outer_field_access_fix
12195              detects we write into a final. */
12196           if (nn == error_mark_node)
12197             return error_mark_node;
12198           node = nn;
12199         }
12200       else
12201         {
12202           node = patch_assignment (node, wfl_op1);
12203           if (node == error_mark_node)
12204             return error_mark_node;
12205           /* Reorganize the tree if necessary. */
12206           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12207                        || JSTRING_P (TREE_TYPE (node))))
12208             node = java_refold (node);
12209         }
12210
12211       /* Seek to set DECL_INITIAL to a proper value, since it might have
12212          undergone a conversion in patch_assignment. We do that only when
12213          it's necessary to have DECL_INITIAL properly set. */
12214       nn = TREE_OPERAND (node, 0);
12215       if (TREE_CODE (nn) == VAR_DECL
12216           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12217           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12218           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12219               || TREE_TYPE (nn) == string_ptr_type_node))
12220         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12221
12222       CAN_COMPLETE_NORMALLY (node) = 1;
12223       return node;
12224
12225     case MULT_EXPR:
12226     case PLUS_EXPR:
12227     case MINUS_EXPR:
12228     case LSHIFT_EXPR:
12229     case RSHIFT_EXPR:
12230     case URSHIFT_EXPR:
12231     case BIT_AND_EXPR:
12232     case BIT_XOR_EXPR:
12233     case BIT_IOR_EXPR:
12234     case TRUNC_MOD_EXPR:
12235     case TRUNC_DIV_EXPR:
12236     case RDIV_EXPR:
12237     case TRUTH_ANDIF_EXPR:
12238     case TRUTH_ORIF_EXPR:
12239     case EQ_EXPR:
12240     case NE_EXPR:
12241     case GT_EXPR:
12242     case GE_EXPR:
12243     case LT_EXPR:
12244     case LE_EXPR:
12245       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12246          knows how to handle those cases. */
12247       wfl_op1 = TREE_OPERAND (node, 0);
12248       wfl_op2 = TREE_OPERAND (node, 1);
12249
12250       CAN_COMPLETE_NORMALLY (node) = 1;
12251       /* Don't complete string nodes if dealing with the PLUS operand. */
12252       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12253         {
12254           nn = java_complete_tree (wfl_op1);
12255           if (nn == error_mark_node)
12256             return error_mark_node;
12257
12258           TREE_OPERAND (node, 0) = nn;
12259         }
12260       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12261         {
12262           nn = java_complete_tree (wfl_op2);
12263           if (nn == error_mark_node)
12264             return error_mark_node;
12265
12266           TREE_OPERAND (node, 1) = nn;
12267         }
12268       return force_evaluation_order (patch_binop (node, wfl_op1, wfl_op2));
12269
12270     case INSTANCEOF_EXPR:
12271       wfl_op1 = TREE_OPERAND (node, 0);
12272       COMPLETE_CHECK_OP_0 (node);
12273       if (flag_emit_xref)
12274         {
12275           TREE_TYPE (node) = boolean_type_node;
12276           return node;
12277         }
12278       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12279
12280     case UNARY_PLUS_EXPR:
12281     case NEGATE_EXPR:
12282     case TRUTH_NOT_EXPR:
12283     case BIT_NOT_EXPR:
12284     case PREDECREMENT_EXPR:
12285     case PREINCREMENT_EXPR:
12286     case POSTDECREMENT_EXPR:
12287     case POSTINCREMENT_EXPR:
12288     case CONVERT_EXPR:
12289       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12290          how to handle those cases. */
12291       wfl_op1 = TREE_OPERAND (node, 0);
12292       CAN_COMPLETE_NORMALLY (node) = 1;
12293       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12294       if (TREE_OPERAND (node, 0) == error_mark_node)
12295         return error_mark_node;
12296       node = patch_unaryop (node, wfl_op1);
12297       CAN_COMPLETE_NORMALLY (node) = 1;
12298       break;
12299
12300     case ARRAY_REF:
12301       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12302          how to handle those cases. */
12303       wfl_op1 = TREE_OPERAND (node, 0);
12304       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12305       if (TREE_OPERAND (node, 0) == error_mark_node)
12306         return error_mark_node;
12307       if (!flag_emit_class_files && !flag_emit_xref)
12308         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12309       /* The same applies to wfl_op2 */
12310       wfl_op2 = TREE_OPERAND (node, 1);
12311       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12312       if (TREE_OPERAND (node, 1) == error_mark_node)
12313         return error_mark_node;
12314       if (!flag_emit_class_files && !flag_emit_xref)
12315         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12316       return patch_array_ref (node);
12317
12318     case RECORD_TYPE:
12319       return node;;
12320
12321     case COMPONENT_REF:
12322       /* The first step in the re-write of qualified name handling.  FIXME.
12323          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12324       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12325       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12326         {
12327           tree name = TREE_OPERAND (node, 1);
12328           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12329           if (field == NULL_TREE)
12330             {
12331               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12332               return error_mark_node;
12333             }
12334           if (! FIELD_STATIC (field))
12335             {
12336               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12337               return error_mark_node;
12338             }
12339           return field;
12340         }
12341       else
12342         abort ();
12343       break;
12344
12345     case THIS_EXPR:
12346       /* Can't use THIS in a static environment */
12347       if (!current_this)
12348         {
12349           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12350           parse_error_context (wfl_operator,
12351                                "Keyword `this' used outside allowed context");
12352           TREE_TYPE (node) = error_mark_node;
12353           return error_mark_node;
12354         }
12355       if (ctxp->explicit_constructor_p)
12356         {
12357           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12358           parse_error_context
12359             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12360           TREE_TYPE (node) = error_mark_node;
12361           return error_mark_node;
12362         }
12363       return current_this;
12364
12365     case CLASS_LITERAL:
12366       CAN_COMPLETE_NORMALLY (node) = 1;
12367       node = patch_incomplete_class_ref (node);
12368       if (node == error_mark_node)
12369         return error_mark_node;
12370       break;
12371
12372     default:
12373       CAN_COMPLETE_NORMALLY (node) = 1;
12374       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12375          and it's time to turn it into the appropriate String object */
12376       if ((nn = patch_string (node)))
12377         node = nn;
12378       else
12379         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12380     }
12381   return node;
12382 }
12383
12384 /* Complete function call's argument. Return a nonzero value is an
12385    error was found.  */
12386
12387 static int
12388 complete_function_arguments (tree node)
12389 {
12390   int flag = 0;
12391   tree cn;
12392
12393   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12394   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12395     {
12396       tree wfl = TREE_VALUE (cn), parm, temp;
12397       parm = java_complete_tree (wfl);
12398
12399       if (parm == error_mark_node)
12400         {
12401           flag = 1;
12402           continue;
12403         }
12404       /* If have a string literal that we haven't transformed yet or a
12405          crafted string buffer, as a result of use of the the String
12406          `+' operator. Build `parm.toString()' and expand it. */
12407       if ((temp = patch_string (parm)))
12408         parm = temp;
12409
12410       TREE_VALUE (cn) = parm;
12411     }
12412   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12413   return flag;
12414 }
12415
12416 /* Sometimes (for loops and variable initialized during their
12417    declaration), we want to wrap a statement around a WFL and turn it
12418    debugable.  */
12419
12420 static tree
12421 build_debugable_stmt (int location, tree stmt)
12422 {
12423   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12424     {
12425       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12426       EXPR_WFL_LINECOL (stmt) = location;
12427     }
12428   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12429   return stmt;
12430 }
12431
12432 static tree
12433 build_expr_block (tree body, tree decls)
12434
12435 {
12436   tree node = make_node (BLOCK);
12437   BLOCK_EXPR_DECLS (node) = decls;
12438   BLOCK_EXPR_BODY (node) = body;
12439   if (body)
12440     TREE_TYPE (node) = TREE_TYPE (body);
12441   TREE_SIDE_EFFECTS (node) = 1;
12442   return node;
12443 }
12444
12445 /* Create a new function block and link it appropriately to current
12446    function block chain */
12447
12448 static tree
12449 enter_block (void)
12450 {
12451   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12452
12453   /* Link block B supercontext to the previous block. The current
12454      function DECL is used as supercontext when enter_a_block is called
12455      for the first time for a given function. The current function body
12456      (DECL_FUNCTION_BODY) is set to be block B.  */
12457
12458   tree fndecl = current_function_decl;
12459
12460   if (!fndecl) {
12461     BLOCK_SUPERCONTEXT (b) = current_static_block;
12462     current_static_block = b;
12463   }
12464
12465   else if (!DECL_FUNCTION_BODY (fndecl))
12466     {
12467       BLOCK_SUPERCONTEXT (b) = fndecl;
12468       DECL_FUNCTION_BODY (fndecl) = b;
12469     }
12470   else
12471     {
12472       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12473       DECL_FUNCTION_BODY (fndecl) = b;
12474     }
12475   return b;
12476 }
12477
12478 /* Exit a block by changing the current function body
12479    (DECL_FUNCTION_BODY) to the current block super context, only if
12480    the block being exited isn't the method's top level one.  */
12481
12482 static tree
12483 exit_block (void)
12484 {
12485   tree b;
12486   if (current_function_decl)
12487     {
12488       b = DECL_FUNCTION_BODY (current_function_decl);
12489       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12490         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12491     }
12492   else
12493     {
12494       b = current_static_block;
12495
12496       if (BLOCK_SUPERCONTEXT (b))
12497         current_static_block = BLOCK_SUPERCONTEXT (b);
12498     }
12499   return b;
12500 }
12501
12502 /* Lookup for NAME in the nested function's blocks, all the way up to
12503    the current toplevel one. It complies with Java's local variable
12504    scoping rules.  */
12505
12506 static tree
12507 lookup_name_in_blocks (tree name)
12508 {
12509   tree b = GET_CURRENT_BLOCK (current_function_decl);
12510
12511   while (b != current_function_decl)
12512     {
12513       tree current;
12514
12515       /* Paranoid sanity check. To be removed */
12516       if (TREE_CODE (b) != BLOCK)
12517         abort ();
12518
12519       for (current = BLOCK_EXPR_DECLS (b); current;
12520            current = TREE_CHAIN (current))
12521         if (DECL_NAME (current) == name)
12522           return current;
12523       b = BLOCK_SUPERCONTEXT (b);
12524     }
12525   return NULL_TREE;
12526 }
12527
12528 static void
12529 maybe_absorb_scoping_blocks (void)
12530 {
12531   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12532     {
12533       tree b = exit_block ();
12534       java_method_add_stmt (current_function_decl, b);
12535       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12536     }
12537 }
12538
12539 \f
12540 /* This section of the source is reserved to build_* functions that
12541    are building incomplete tree nodes and the patch_* functions that
12542    are completing them.  */
12543
12544 /* Wrap a non WFL node around a WFL.  */
12545
12546 static tree
12547 build_wfl_wrap (tree node, int location)
12548 {
12549   tree wfl, node_to_insert = node;
12550
12551   /* We want to process THIS . xxx symbolicaly, to keep it consistent
12552      with the way we're processing SUPER. A THIS from a primary as a
12553      different form than a SUPER. Turn THIS into something symbolic */
12554   if (TREE_CODE (node) == THIS_EXPR)
12555     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12556   else
12557     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12558
12559   EXPR_WFL_LINECOL (wfl) = location;
12560   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12561   return wfl;
12562 }
12563
12564 /* Build a super() constructor invocation. Returns empty_stmt_node if
12565    we're currently dealing with the class java.lang.Object. */
12566
12567 static tree
12568 build_super_invocation (tree mdecl)
12569 {
12570   if (DECL_CONTEXT (mdecl) == object_type_node)
12571     return empty_stmt_node;
12572   else
12573     {
12574       tree super_wfl = build_wfl_node (super_identifier_node);
12575       tree a = NULL_TREE, t;
12576       /* If we're dealing with an anonymous class, pass the arguments
12577          of the crafted constructor along. */
12578       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12579         {
12580           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12581           for (; t != end_params_node; t = TREE_CHAIN (t))
12582             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12583         }
12584       return build_method_invocation (super_wfl, a);
12585     }
12586 }
12587
12588 /* Build a SUPER/THIS qualified method invocation.  */
12589
12590 static tree
12591 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12592                                        int lloc, int rloc)
12593 {
12594   tree invok;
12595   tree wfl =
12596     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12597   EXPR_WFL_LINECOL (wfl) = lloc;
12598   invok = build_method_invocation (name, args);
12599   return make_qualified_primary (wfl, invok, rloc);
12600 }
12601
12602 /* Build an incomplete CALL_EXPR node. */
12603
12604 static tree
12605 build_method_invocation (tree name, tree args)
12606 {
12607   tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12608   TREE_SIDE_EFFECTS (call) = 1;
12609   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12610   return call;
12611 }
12612
12613 /* Build an incomplete new xxx(...) node. */
12614
12615 static tree
12616 build_new_invocation (tree name, tree args)
12617 {
12618   tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12619   TREE_SIDE_EFFECTS (call) = 1;
12620   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12621   return call;
12622 }
12623
12624 /* Build an incomplete assignment expression. */
12625
12626 static tree
12627 build_assignment (int op, int op_location, tree lhs, tree rhs)
12628 {
12629   tree assignment;
12630   /* Build the corresponding binop if we deal with a Compound
12631      Assignment operator. Mark the binop sub-tree as part of a
12632      Compound Assignment expression */
12633   if (op != ASSIGN_TK)
12634     {
12635       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12636       COMPOUND_ASSIGN_P (rhs) = 1;
12637     }
12638   assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12639   TREE_SIDE_EFFECTS (assignment) = 1;
12640   EXPR_WFL_LINECOL (assignment) = op_location;
12641   return assignment;
12642 }
12643
12644 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12645    the buffer.  This is used only for string conversion.  */
12646 static char *
12647 string_convert_int_cst (tree node)
12648 {
12649   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12650   static char buffer[21];
12651
12652   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12653   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12654   char *p = buffer + sizeof (buffer);
12655   int neg = 0;
12656
12657   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12658                                   << (HOST_BITS_PER_WIDE_INT - 1));
12659
12660   *--p = '\0';
12661
12662   /* If negative, note the fact and negate the value.  */
12663   if ((hi & hibit))
12664     {
12665       lo = ~lo;
12666       hi = ~hi;
12667       if (++lo == 0)
12668         ++hi;
12669       neg = 1;
12670     }
12671
12672   /* Divide by 10 until there are no bits left.  */
12673   do
12674     {
12675       unsigned HOST_WIDE_INT acc = 0;
12676       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12677       unsigned int i;
12678
12679       /* Use long division to compute the result and the remainder.  */
12680       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12681         {
12682           /* Shift a bit into accumulator.  */
12683           acc <<= 1;
12684           if ((hi & hibit))
12685             acc |= 1;
12686
12687           /* Shift the value.  */
12688           hi <<= 1;
12689           if ((lo & hibit))
12690             hi |= 1;
12691           lo <<= 1;
12692
12693           /* Shift the correct bit into the result.  */
12694           outhi <<= 1;
12695           if ((outlo & hibit))
12696             outhi |= 1;
12697           outlo <<= 1;
12698           if (acc >= 10)
12699             {
12700               acc -= 10;
12701               outlo |= 1;
12702             }
12703         }
12704
12705       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12706       *--p = '\060' + acc;
12707
12708       hi = outhi;
12709       lo = outlo;
12710     }
12711   while (hi || lo);
12712
12713   if (neg)
12714     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12715
12716   return p;
12717 }
12718
12719 /* Print an INTEGER_CST node in a static buffer, and return the
12720    buffer.  This is used only for error handling.  */
12721 char *
12722 print_int_node (tree node)
12723 {
12724   static char buffer [80];
12725   if (TREE_CONSTANT_OVERFLOW (node))
12726     sprintf (buffer, "<overflow>");
12727
12728   if (TREE_INT_CST_HIGH (node) == 0)
12729     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12730              TREE_INT_CST_LOW (node));
12731   else if (TREE_INT_CST_HIGH (node) == -1
12732            && TREE_INT_CST_LOW (node) != 0)
12733     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12734              -TREE_INT_CST_LOW (node));
12735   else
12736     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12737              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12738
12739   return buffer;
12740 }
12741
12742 \f
12743 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12744    context.  */
12745
12746 /* 15.25 Assignment operators. */
12747
12748 static tree
12749 patch_assignment (tree node, tree wfl_op1)
12750 {
12751   tree rhs = TREE_OPERAND (node, 1);
12752   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12753   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12754   int error_found = 0;
12755   int lvalue_from_array = 0;
12756   int is_return = 0;
12757
12758   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12759
12760   /* Lhs can be a named variable */
12761   if (JDECL_P (lvalue))
12762     {
12763       lhs_type = TREE_TYPE (lvalue);
12764     }
12765   /* Or Lhs can be an array access. */
12766   else if (TREE_CODE (lvalue) == ARRAY_REF)
12767     {
12768       lhs_type = TREE_TYPE (lvalue);
12769       lvalue_from_array = 1;
12770     }
12771   /* Or a field access */
12772   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12773     lhs_type = TREE_TYPE (lvalue);
12774   /* Or a function return slot */
12775   else if (TREE_CODE (lvalue) == RESULT_DECL)
12776     {
12777       /* If the return type is an integral type, then we create the
12778          RESULT_DECL with a promoted type, but we need to do these
12779          checks against the unpromoted type to ensure type safety.  So
12780          here we look at the real type, not the type of the decl we
12781          are modifying.  */
12782       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12783       is_return = 1;
12784     }
12785   /* Otherwise, we might want to try to write into an optimized static
12786      final, this is an of a different nature, reported further on. */
12787   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12788            && resolve_expression_name (wfl_op1, &llvalue))
12789     {
12790       lhs_type = TREE_TYPE (lvalue);
12791     }
12792   else
12793     {
12794       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12795       error_found = 1;
12796     }
12797
12798   rhs_type = TREE_TYPE (rhs);
12799
12800   /* 5.1 Try the assignment conversion for builtin type. */
12801   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12802
12803   /* 5.2 If it failed, try a reference conversion */
12804   if (!new_rhs && (new_rhs = try_reference_assignconv (lhs_type, rhs)))
12805     lhs_type = promote_type (rhs_type);
12806
12807   /* 15.25.2 If we have a compound assignment, convert RHS into the
12808      type of the LHS */
12809   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12810     new_rhs = convert (lhs_type, rhs);
12811
12812   /* Explicit cast required. This is an error */
12813   if (!new_rhs)
12814     {
12815       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12816       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12817       tree wfl;
12818       char operation [32];      /* Max size known */
12819
12820       /* If the assignment is part of a declaration, we use the WFL of
12821          the declared variable to point out the error and call it a
12822          declaration problem. If the assignment is a genuine =
12823          operator, we call is a operator `=' problem, otherwise we
12824          call it an assignment problem. In both of these last cases,
12825          we use the WFL of the operator to indicate the error. */
12826
12827       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12828         {
12829           wfl = wfl_op1;
12830           strcpy (operation, "declaration");
12831         }
12832       else
12833         {
12834           wfl = wfl_operator;
12835           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12836             strcpy (operation, "assignment");
12837           else if (is_return)
12838             strcpy (operation, "`return'");
12839           else
12840             strcpy (operation, "`='");
12841         }
12842
12843       if (!valid_cast_to_p (rhs_type, lhs_type))
12844         parse_error_context
12845           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12846            operation, t1, t2);
12847       else
12848         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12849                              operation, t1, t2);
12850       free (t1); free (t2);
12851       error_found = 1;
12852     }
12853
12854   if (error_found)
12855     return error_mark_node;
12856
12857   /* If we're processing a `return' statement, promote the actual type
12858      to the promoted type.  */
12859   if (is_return)
12860     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12861
12862   /* 10.10: Array Store Exception runtime check */
12863   if (!flag_emit_class_files
12864       && !flag_emit_xref
12865       && lvalue_from_array
12866       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12867     {
12868       tree array, store_check, base, index_expr;
12869
12870       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12871       new_rhs = save_expr (new_rhs);
12872
12873       /* Get the INDIRECT_REF. */
12874       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12875       /* Get the array pointer expr. */
12876       array = TREE_OPERAND (array, 0);
12877       store_check = build_java_arraystore_check (array, new_rhs);
12878
12879       index_expr = TREE_OPERAND (lvalue, 1);
12880
12881       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12882         {
12883           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12884              happen before the store check, so prepare to insert the store
12885              check within the second operand of the existing COMPOUND_EXPR. */
12886           base = index_expr;
12887         }
12888       else
12889         base = lvalue;
12890
12891       index_expr = TREE_OPERAND (base, 1);
12892       TREE_OPERAND (base, 1) = build (COMPOUND_EXPR, TREE_TYPE (index_expr),
12893                                       store_check, index_expr);
12894     }
12895
12896   /* Final locals can be used as case values in switch
12897      statement. Prepare them for this eventuality. */
12898   if (TREE_CODE (lvalue) == VAR_DECL
12899       && DECL_FINAL (lvalue)
12900       && TREE_CONSTANT (new_rhs)
12901       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12902       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12903       )
12904     {
12905       TREE_CONSTANT (lvalue) = 1;
12906       DECL_INITIAL (lvalue) = new_rhs;
12907     }
12908
12909   /* Copy the rhs if it's a reference.  */
12910   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12911     {
12912       switch (TREE_CODE (new_rhs))
12913         {
12914         case ARRAY_REF:
12915         case INDIRECT_REF:
12916         case COMPONENT_REF:
12917           /* Transform a = foo.bar
12918              into a = { int tmp; tmp = foo.bar; tmp; ).
12919              We need to ensure that if a read from memory fails
12920              because of a NullPointerException, a destination variable
12921              will remain unchanged.  An explicit temporary does what
12922              we need.
12923
12924              If flag_check_references is set, this is unnecessary
12925              because we'll check each reference before doing any
12926              reads.  If optimize is not set the result will never be
12927              written to a stack slot that contains the LHS.  */
12928           {
12929             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12930                                    TREE_TYPE (new_rhs));
12931             tree block = build (BLOCK, TREE_TYPE (new_rhs), NULL);
12932             tree assignment
12933               = build (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12934             DECL_CONTEXT (tmp) = current_function_decl;
12935             BLOCK_VARS (block) = tmp;
12936             BLOCK_EXPR_BODY (block)
12937               = build (COMPOUND_EXPR, TREE_TYPE (new_rhs), assignment, tmp);
12938             TREE_SIDE_EFFECTS (block) = 1;
12939             new_rhs = block;
12940           }
12941           break;
12942         default:
12943           break;
12944         }
12945     }
12946
12947   TREE_OPERAND (node, 0) = lvalue;
12948   TREE_OPERAND (node, 1) = new_rhs;
12949   TREE_TYPE (node) = lhs_type;
12950   return node;
12951 }
12952
12953 /* Check that type SOURCE can be cast into type DEST. If the cast
12954    can't occur at all, return NULL; otherwise, return a possibly
12955    modified rhs.  */
12956
12957 static tree
12958 try_reference_assignconv (tree lhs_type, tree rhs)
12959 {
12960   tree new_rhs = NULL_TREE;
12961   tree rhs_type = TREE_TYPE (rhs);
12962
12963   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12964     {
12965       /* `null' may be assigned to any reference type */
12966       if (rhs == null_pointer_node)
12967         new_rhs = null_pointer_node;
12968       /* Try the reference assignment conversion */
12969       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12970         new_rhs = rhs;
12971       /* This is a magic assignment that we process differently */
12972       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12973         new_rhs = rhs;
12974     }
12975   return new_rhs;
12976 }
12977
12978 /* Check that RHS can be converted into LHS_TYPE by the assignment
12979    conversion (5.2), for the cases of RHS being a builtin type. Return
12980    NULL_TREE if the conversion fails or if because RHS isn't of a
12981    builtin type. Return a converted RHS if the conversion is possible.  */
12982
12983 static tree
12984 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12985 {
12986   tree new_rhs = NULL_TREE;
12987   tree rhs_type = TREE_TYPE (rhs);
12988
12989   /* Handle boolean specially.  */
12990   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12991       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12992     {
12993       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12994           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12995         new_rhs = rhs;
12996     }
12997
12998   /* 5.1.1 Try Identity Conversion,
12999      5.1.2 Try Widening Primitive Conversion */
13000   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
13001     new_rhs = convert (lhs_type, rhs);
13002
13003   /* Try a narrowing primitive conversion (5.1.3):
13004        - expression is a constant expression of type byte, short, char,
13005          or int, AND
13006        - variable is byte, short or char AND
13007        - The value of the expression is representable in the type of the
13008          variable */
13009   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
13010             || rhs_type == char_type_node || rhs_type == int_type_node)
13011             && TREE_CONSTANT (rhs)
13012            && (lhs_type == byte_type_node || lhs_type == char_type_node
13013                || lhs_type == short_type_node))
13014     {
13015       if (int_fits_type_p (rhs, lhs_type))
13016         new_rhs = convert (lhs_type, rhs);
13017       else if (wfl_op1)         /* Might be called with a NULL */
13018         parse_warning_context
13019           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
13020            print_int_node (rhs), lang_printable_name (lhs_type, 0));
13021       /* Reported a warning that will turn into an error further
13022          down, so we don't return */
13023     }
13024
13025   return new_rhs;
13026 }
13027
13028 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
13029    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
13030    0 is the conversion test fails.  This implements parts the method
13031    invocation convertion (5.3).  */
13032
13033 static int
13034 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
13035 {
13036   /* 5.1.1: This is the identity conversion part. */
13037   if (lhs_type == rhs_type)
13038     return 1;
13039
13040   /* Reject non primitive types and boolean conversions.  */
13041   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
13042     return 0;
13043
13044   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
13045      than a char can't be converted into a char. Short can't too, but
13046      the < test below takes care of that */
13047   if (lhs_type == char_type_node && rhs_type == byte_type_node)
13048     return 0;
13049
13050   /* Accept all promoted type here. Note, we can't use <= in the test
13051      below, because we still need to bounce out assignments of short
13052      to char and the likes */
13053   if (lhs_type == int_type_node
13054       && (rhs_type == promoted_byte_type_node
13055           || rhs_type == promoted_short_type_node
13056           || rhs_type == promoted_char_type_node
13057           || rhs_type == promoted_boolean_type_node))
13058     return 1;
13059
13060   /* From here, an integral is widened if its precision is smaller
13061      than the precision of the LHS or if the LHS is a floating point
13062      type, or the RHS is a float and the RHS a double. */
13063   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
13064        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
13065       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
13066       || (rhs_type == float_type_node && lhs_type == double_type_node))
13067     return 1;
13068
13069   return 0;
13070 }
13071
13072 /* Check that something of SOURCE type can be assigned or cast to
13073    something of DEST type at runtime. Return 1 if the operation is
13074    valid, 0 otherwise. If CAST is set to 1, we're treating the case
13075    were SOURCE is cast into DEST, which borrows a lot of the
13076    assignment check. */
13077
13078 static int
13079 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
13080 {
13081   /* SOURCE or DEST might be null if not from a declared entity. */
13082   if (!source || !dest)
13083     return 0;
13084   if (JNULLP_TYPE_P (source))
13085     return 1;
13086   if (TREE_CODE (source) == POINTER_TYPE)
13087     source = TREE_TYPE (source);
13088   if (TREE_CODE (dest) == POINTER_TYPE)
13089     dest = TREE_TYPE (dest);
13090
13091   /* If source and dest are being compiled from bytecode, they may need to
13092      be loaded. */
13093   if (CLASS_P (source) && !CLASS_LOADED_P (source))
13094     {
13095       load_class (source, 1);
13096       safe_layout_class (source);
13097     }
13098   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
13099     {
13100       load_class (dest, 1);
13101       safe_layout_class (dest);
13102     }
13103
13104   /* Case where SOURCE is a class type */
13105   if (TYPE_CLASS_P (source))
13106     {
13107       if (TYPE_CLASS_P (dest))
13108         return  (source == dest
13109                  || inherits_from_p (source, dest)
13110                  || (cast && inherits_from_p (dest, source)));
13111       if (TYPE_INTERFACE_P (dest))
13112         {
13113           /* If doing a cast and SOURCE is final, the operation is
13114              always correct a compile time (because even if SOURCE
13115              does not implement DEST, a subclass of SOURCE might). */
13116           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
13117             return 1;
13118           /* Otherwise, SOURCE must implement DEST */
13119           return interface_of_p (dest, source);
13120         }
13121       /* DEST is an array, cast permited if SOURCE is of Object type */
13122       return (cast && source == object_type_node ? 1 : 0);
13123     }
13124   if (TYPE_INTERFACE_P (source))
13125     {
13126       if (TYPE_CLASS_P (dest))
13127         {
13128           /* If not casting, DEST must be the Object type */
13129           if (!cast)
13130             return dest == object_type_node;
13131           /* We're doing a cast. The cast is always valid is class
13132              DEST is not final, otherwise, DEST must implement SOURCE */
13133           else if (!CLASS_FINAL (TYPE_NAME (dest)))
13134             return 1;
13135           else
13136             return interface_of_p (source, dest);
13137         }
13138       if (TYPE_INTERFACE_P (dest))
13139         {
13140           /* If doing a cast, then if SOURCE and DEST contain method
13141              with the same signature but different return type, then
13142              this is a (compile time) error */
13143           if (cast)
13144             {
13145               tree method_source, method_dest;
13146               tree source_type;
13147               tree source_sig;
13148               tree source_name;
13149               for (method_source = TYPE_METHODS (source); method_source;
13150                    method_source = TREE_CHAIN (method_source))
13151                 {
13152                   source_sig =
13153                     build_java_argument_signature (TREE_TYPE (method_source));
13154                   source_type = TREE_TYPE (TREE_TYPE (method_source));
13155                   source_name = DECL_NAME (method_source);
13156                   for (method_dest = TYPE_METHODS (dest);
13157                        method_dest; method_dest = TREE_CHAIN (method_dest))
13158                     if (source_sig ==
13159                         build_java_argument_signature (TREE_TYPE (method_dest))
13160                         && source_name == DECL_NAME (method_dest)
13161                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
13162                       return 0;
13163                 }
13164               return 1;
13165             }
13166           else
13167             return source == dest || interface_of_p (dest, source);
13168         }
13169       else
13170         {
13171           /* Array */
13172           return (cast
13173                   && (DECL_NAME (TYPE_NAME (source))
13174                       == java_lang_cloneable_identifier_node
13175                       || (DECL_NAME (TYPE_NAME (source))
13176                           == java_io_serializable_identifier_node)));
13177         }
13178     }
13179   if (TYPE_ARRAY_P (source))
13180     {
13181       if (TYPE_CLASS_P (dest))
13182         return dest == object_type_node;
13183       /* Can't cast an array to an interface unless the interface is
13184          java.lang.Cloneable or java.io.Serializable.  */
13185       if (TYPE_INTERFACE_P (dest))
13186         return (DECL_NAME (TYPE_NAME (dest))
13187                 == java_lang_cloneable_identifier_node
13188                 || (DECL_NAME (TYPE_NAME (dest))
13189                     == java_io_serializable_identifier_node));
13190       else                      /* Arrays */
13191         {
13192           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13193           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13194
13195           /* In case of severe errors, they turn out null */
13196           if (!dest_element_type || !source_element_type)
13197             return 0;
13198           if (source_element_type == dest_element_type)
13199             return 1;
13200           return valid_ref_assignconv_cast_p (source_element_type,
13201                                               dest_element_type, cast);
13202         }
13203       return 0;
13204     }
13205   return 0;
13206 }
13207
13208 static int
13209 valid_cast_to_p (tree source, tree dest)
13210 {
13211   if (TREE_CODE (source) == POINTER_TYPE)
13212     source = TREE_TYPE (source);
13213   if (TREE_CODE (dest) == POINTER_TYPE)
13214     dest = TREE_TYPE (dest);
13215
13216   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13217     return valid_ref_assignconv_cast_p (source, dest, 1);
13218
13219   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13220     return 1;
13221
13222   else if (TREE_CODE (source) == BOOLEAN_TYPE
13223            && TREE_CODE (dest) == BOOLEAN_TYPE)
13224     return 1;
13225
13226   return 0;
13227 }
13228
13229 static tree
13230 do_unary_numeric_promotion (tree arg)
13231 {
13232   tree type = TREE_TYPE (arg);
13233   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13234       || TREE_CODE (type) == CHAR_TYPE)
13235     arg = convert (int_type_node, arg);
13236   return arg;
13237 }
13238
13239 /* Return a nonzero value if SOURCE can be converted into DEST using
13240    the method invocation conversion rule (5.3).  */
13241 static int
13242 valid_method_invocation_conversion_p (tree dest, tree source)
13243 {
13244   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13245            && valid_builtin_assignconv_identity_widening_p (dest, source))
13246           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13247               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13248               && valid_ref_assignconv_cast_p (source, dest, 0)));
13249 }
13250
13251 /* Build an incomplete binop expression. */
13252
13253 static tree
13254 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13255 {
13256   tree binop = build (op, NULL_TREE, op1, op2);
13257   TREE_SIDE_EFFECTS (binop) = 1;
13258   /* Store the location of the operator, for better error report. The
13259      string of the operator will be rebuild based on the OP value. */
13260   EXPR_WFL_LINECOL (binop) = op_location;
13261   return binop;
13262 }
13263
13264 /* Build the string of the operator retained by NODE. If NODE is part
13265    of a compound expression, add an '=' at the end of the string. This
13266    function is called when an error needs to be reported on an
13267    operator. The string is returned as a pointer to a static character
13268    buffer. */
13269
13270 static char *
13271 operator_string (tree node)
13272 {
13273 #define BUILD_OPERATOR_STRING(S)                                        \
13274   {                                                                     \
13275     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13276     return buffer;                                                      \
13277   }
13278
13279   static char buffer [10];
13280   switch (TREE_CODE (node))
13281     {
13282     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13283     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13284     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13285     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13286     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13287     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13288     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13289     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13290     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13291     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13292     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13293     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13294     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13295     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13296     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13297     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13298     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13299     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13300     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13301     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13302     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13303     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13304     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13305     case PREINCREMENT_EXPR:     /* Fall through */
13306     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13307     case PREDECREMENT_EXPR:     /* Fall through */
13308     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13309     default:
13310       internal_error ("unregistered operator %s",
13311                       tree_code_name [TREE_CODE (node)]);
13312     }
13313   return NULL;
13314 #undef BUILD_OPERATOR_STRING
13315 }
13316
13317 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13318
13319 static int
13320 java_decl_equiv (tree var_acc1, tree var_acc2)
13321 {
13322   if (JDECL_P (var_acc1))
13323     return (var_acc1 == var_acc2);
13324
13325   return (TREE_CODE (var_acc1) == COMPONENT_REF
13326           && TREE_CODE (var_acc2) == COMPONENT_REF
13327           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13328              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13329           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13330 }
13331
13332 /* Return a nonzero value if CODE is one of the operators that can be
13333    used in conjunction with the `=' operator in a compound assignment.  */
13334
13335 static int
13336 binop_compound_p (enum tree_code code)
13337 {
13338   int i;
13339   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13340     if (binop_lookup [i] == code)
13341       break;
13342
13343   return i < BINOP_COMPOUND_CANDIDATES;
13344 }
13345
13346 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13347
13348 static tree
13349 java_refold (tree t)
13350 {
13351   tree c, b, ns, decl;
13352
13353   if (TREE_CODE (t) != MODIFY_EXPR)
13354     return t;
13355
13356   c = TREE_OPERAND (t, 1);
13357   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13358          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13359          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13360     return t;
13361
13362   /* Now the left branch of the binary operator. */
13363   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13364   if (! (b && TREE_CODE (b) == NOP_EXPR
13365          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13366     return t;
13367
13368   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13369   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13370          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13371     return t;
13372
13373   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13374   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13375       /* It's got to be the an equivalent decl */
13376       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13377     {
13378       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13379       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13380       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13381       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13382       /* Change the right part of the BINOP_EXPR */
13383       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13384     }
13385
13386   return t;
13387 }
13388
13389 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13390    errors but we modify NODE so that it contains the type computed
13391    according to the expression, when it's fixed. Otherwise, we write
13392    error_mark_node as the type. It allows us to further the analysis
13393    of remaining nodes and detects more errors in certain cases.  */
13394
13395 static tree
13396 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13397 {
13398   tree op1 = TREE_OPERAND (node, 0);
13399   tree op2 = TREE_OPERAND (node, 1);
13400   tree op1_type = TREE_TYPE (op1);
13401   tree op2_type = TREE_TYPE (op2);
13402   tree prom_type = NULL_TREE, cn;
13403   enum tree_code code = TREE_CODE (node);
13404
13405   /* If 1, tell the routine that we have to return error_mark_node
13406      after checking for the initialization of the RHS */
13407   int error_found = 0;
13408
13409   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13410
13411   /* If either op<n>_type are NULL, this might be early signs of an
13412      error situation, unless it's too early to tell (in case we're
13413      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13414      correctly so the error can be later on reported accurately. */
13415   if (! (code == PLUS_EXPR || code == NE_EXPR
13416          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13417     {
13418       tree n;
13419       if (! op1_type)
13420         {
13421           n = java_complete_tree (op1);
13422           op1_type = TREE_TYPE (n);
13423         }
13424       if (! op2_type)
13425         {
13426           n = java_complete_tree (op2);
13427           op2_type = TREE_TYPE (n);
13428         }
13429     }
13430
13431   switch (code)
13432     {
13433     /* 15.16 Multiplicative operators */
13434     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13435     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13436     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13437     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13438       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13439         {
13440           if (!JNUMERIC_TYPE_P (op1_type))
13441             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13442           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13443             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13444           TREE_TYPE (node) = error_mark_node;
13445           error_found = 1;
13446           break;
13447         }
13448       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13449
13450       /* Detect integral division by zero */
13451       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13452           && TREE_CODE (prom_type) == INTEGER_TYPE
13453           && (op2 == integer_zero_node || op2 == long_zero_node ||
13454               (TREE_CODE (op2) == INTEGER_CST &&
13455                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13456         {
13457           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13458           TREE_CONSTANT (node) = 0;
13459         }
13460
13461       /* Change the division operator if necessary */
13462       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13463         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13464
13465       /* Before divisions as is disapear, try to simplify and bail if
13466          applicable, otherwise we won't perform even simple
13467          simplifications like (1-1)/3. We can't do that with floating
13468          point number, folds can't handle them at this stage. */
13469       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13470           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13471         {
13472           TREE_TYPE (node) = prom_type;
13473           node = fold (node);
13474           if (TREE_CODE (node) != code)
13475             return node;
13476         }
13477
13478       if (TREE_CODE (prom_type) == INTEGER_TYPE
13479           && flag_use_divide_subroutine
13480           && ! flag_emit_class_files
13481           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13482         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13483
13484       /* This one is more complicated. FLOATs are processed by a
13485          function call to soft_fmod. Duplicate the value of the
13486          COMPOUND_ASSIGN_P flag. */
13487       if (code == TRUNC_MOD_EXPR)
13488         {
13489           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13490           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13491           TREE_SIDE_EFFECTS (mod)
13492             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13493           return mod;
13494         }
13495       break;
13496
13497     /* 15.17 Additive Operators */
13498     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13499
13500       /* Operation is valid if either one argument is a string
13501          constant, a String object or a StringBuffer crafted for the
13502          purpose of the a previous usage of the String concatenation
13503          operator */
13504
13505       if (TREE_CODE (op1) == STRING_CST
13506           || TREE_CODE (op2) == STRING_CST
13507           || JSTRING_TYPE_P (op1_type)
13508           || JSTRING_TYPE_P (op2_type)
13509           || IS_CRAFTED_STRING_BUFFER_P (op1)
13510           || IS_CRAFTED_STRING_BUFFER_P (op2))
13511         return build_string_concatenation (op1, op2);
13512
13513     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13514                                    Numeric Types */
13515       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13516         {
13517           if (!JNUMERIC_TYPE_P (op1_type))
13518             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13519           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13520             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13521           TREE_TYPE (node) = error_mark_node;
13522           error_found = 1;
13523           break;
13524         }
13525       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13526       break;
13527
13528     /* 15.18 Shift Operators */
13529     case LSHIFT_EXPR:
13530     case RSHIFT_EXPR:
13531     case URSHIFT_EXPR:
13532       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13533         {
13534           if (!JINTEGRAL_TYPE_P (op1_type))
13535             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13536           else
13537             {
13538               if (JNUMERIC_TYPE_P (op2_type))
13539                 parse_error_context (wfl_operator,
13540                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13541                                      operator_string (node),
13542                                      lang_printable_name (op2_type, 0));
13543               else
13544                 parse_error_context (wfl_operator,
13545                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13546                                      operator_string (node),
13547                                      lang_printable_name (op2_type, 0));
13548             }
13549           TREE_TYPE (node) = error_mark_node;
13550           error_found = 1;
13551           break;
13552         }
13553
13554       /* Unary numeric promotion (5.6.1) is performed on each operand
13555          separately */
13556       op1 = do_unary_numeric_promotion (op1);
13557       op2 = do_unary_numeric_promotion (op2);
13558
13559       /* If the right hand side is of type `long', first cast it to
13560          `int'.  */
13561       if (TREE_TYPE (op2) == long_type_node)
13562         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13563
13564       /* The type of the shift expression is the type of the promoted
13565          type of the left-hand operand */
13566       prom_type = TREE_TYPE (op1);
13567
13568       /* Shift int only up to 0x1f and long up to 0x3f */
13569       if (prom_type == int_type_node)
13570         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13571                            build_int_2 (0x1f, 0)));
13572       else
13573         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13574                            build_int_2 (0x3f, 0)));
13575
13576       /* The >>> operator is a >> operating on unsigned quantities */
13577       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13578         {
13579           tree to_return;
13580           tree utype = java_unsigned_type (prom_type);
13581           op1 = convert (utype, op1);
13582           TREE_SET_CODE (node, RSHIFT_EXPR);
13583           TREE_OPERAND (node, 0) = op1;
13584           TREE_OPERAND (node, 1) = op2;
13585           TREE_TYPE (node) = utype;
13586           to_return = convert (prom_type, node);
13587           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13588           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13589           TREE_SIDE_EFFECTS (to_return)
13590             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13591           return to_return;
13592         }
13593       break;
13594
13595       /* 15.19.1 Type Comparison Operator instanceof */
13596     case INSTANCEOF_EXPR:
13597
13598       TREE_TYPE (node) = boolean_type_node;
13599
13600       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13601       if ((cn = patch_string (op1)))
13602         {
13603           op1 = cn;
13604           op1_type = TREE_TYPE (op1);
13605         }
13606       if (op1_type == NULL_TREE)
13607         abort ();
13608
13609       if (!(op2_type = resolve_type_during_patch (op2)))
13610         return error_mark_node;
13611
13612       /* The first operand must be a reference type or the null type */
13613       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13614         error_found = 1;        /* Error reported further below */
13615
13616       /* The second operand must be a reference type */
13617       if (!JREFERENCE_TYPE_P (op2_type))
13618         {
13619           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13620           parse_error_context
13621             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13622              lang_printable_name (op2_type, 0));
13623           error_found = 1;
13624         }
13625
13626       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13627         {
13628           /* If the first operand is null, the result is always false */
13629           if (op1 == null_pointer_node)
13630             return boolean_false_node;
13631           else if (flag_emit_class_files)
13632             {
13633               TREE_OPERAND (node, 1) = op2_type;
13634               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13635               return node;
13636             }
13637           /* Otherwise we have to invoke instance of to figure it out */
13638           else
13639             return build_instanceof (op1, op2_type);
13640         }
13641       /* There is no way the expression operand can be an instance of
13642          the type operand. This is a compile time error. */
13643       else
13644         {
13645           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13646           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13647           parse_error_context
13648             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13649              t1, lang_printable_name (op2_type, 0));
13650           free (t1);
13651           error_found = 1;
13652         }
13653
13654       break;
13655
13656       /* 15.21 Bitwise and Logical Operators */
13657     case BIT_AND_EXPR:
13658     case BIT_XOR_EXPR:
13659     case BIT_IOR_EXPR:
13660       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13661         /* Binary numeric promotion is performed on both operand and the
13662            expression retain that type */
13663         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13664
13665       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13666                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13667         /* The type of the bitwise operator expression is BOOLEAN */
13668         prom_type = boolean_type_node;
13669       else
13670         {
13671           if (!JINTEGRAL_TYPE_P (op1_type))
13672             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13673           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13674             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13675           TREE_TYPE (node) = error_mark_node;
13676           error_found = 1;
13677           /* Insert a break here if adding thing before the switch's
13678              break for this case */
13679         }
13680       break;
13681
13682       /* 15.22 Conditional-And Operator */
13683     case TRUTH_ANDIF_EXPR:
13684       /* 15.23 Conditional-Or Operator */
13685     case TRUTH_ORIF_EXPR:
13686       /* Operands must be of BOOLEAN type */
13687       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13688           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13689         {
13690           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13691             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13692           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13693             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13694           TREE_TYPE (node) = boolean_type_node;
13695           error_found = 1;
13696           break;
13697         }
13698       else if (integer_zerop (op1))
13699         {
13700           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13701         }
13702       else if (integer_onep (op1))
13703         {
13704           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13705         }
13706       /* The type of the conditional operators is BOOLEAN */
13707       prom_type = boolean_type_node;
13708       break;
13709
13710       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13711     case LT_EXPR:
13712     case GT_EXPR:
13713     case LE_EXPR:
13714     case GE_EXPR:
13715       /* The type of each of the operands must be a primitive numeric
13716          type */
13717       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13718         {
13719           if (!JNUMERIC_TYPE_P (op1_type))
13720             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13721           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13722             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13723           TREE_TYPE (node) = boolean_type_node;
13724           error_found = 1;
13725           break;
13726         }
13727       /* Binary numeric promotion is performed on the operands */
13728       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13729       /* The type of the relation expression is always BOOLEAN */
13730       prom_type = boolean_type_node;
13731       break;
13732
13733       /* 15.20 Equality Operator */
13734     case EQ_EXPR:
13735     case NE_EXPR:
13736       /* It's time for us to patch the strings. */
13737       if ((cn = patch_string (op1)))
13738        {
13739          op1 = cn;
13740          op1_type = TREE_TYPE (op1);
13741        }
13742       if ((cn = patch_string (op2)))
13743        {
13744          op2 = cn;
13745          op2_type = TREE_TYPE (op2);
13746        }
13747
13748       /* 15.20.1 Numerical Equality Operators == and != */
13749       /* Binary numeric promotion is performed on the operands */
13750       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13751         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13752
13753       /* 15.20.2 Boolean Equality Operators == and != */
13754       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13755           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13756         ;                       /* Nothing to do here */
13757
13758       /* 15.20.3 Reference Equality Operators == and != */
13759       /* Types have to be either references or the null type. If
13760          they're references, it must be possible to convert either
13761          type to the other by casting conversion. */
13762       else if (op1 == null_pointer_node || op2 == null_pointer_node
13763                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13764                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13765                        || valid_ref_assignconv_cast_p (op2_type,
13766                                                        op1_type, 1))))
13767         ;                       /* Nothing to do here */
13768
13769       /* Else we have an error figure what can't be converted into
13770          what and report the error */
13771       else
13772         {
13773           char *t1;
13774           t1 = xstrdup (lang_printable_name (op1_type, 0));
13775           parse_error_context
13776             (wfl_operator,
13777              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13778              operator_string (node), t1,
13779              lang_printable_name (op2_type, 0));
13780           free (t1);
13781           TREE_TYPE (node) = boolean_type_node;
13782           error_found = 1;
13783           break;
13784         }
13785       prom_type = boolean_type_node;
13786       break;
13787     default:
13788       abort ();
13789     }
13790
13791   if (error_found)
13792     return error_mark_node;
13793
13794   TREE_OPERAND (node, 0) = op1;
13795   TREE_OPERAND (node, 1) = op2;
13796   TREE_TYPE (node) = prom_type;
13797   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13798
13799   if (flag_emit_xref)
13800     return node;
13801
13802   /* fold does not respect side-effect order as required for Java but not C.
13803    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13804    * bytecode.
13805    */
13806   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13807       : ! TREE_SIDE_EFFECTS (node))
13808     node = fold (node);
13809   return node;
13810 }
13811
13812 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13813    zero value, the value of CSTE comes after the valude of STRING */
13814
13815 static tree
13816 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13817 {
13818   const char *old = TREE_STRING_POINTER (cste);
13819   int old_len = TREE_STRING_LENGTH (cste);
13820   int len = old_len + string_len;
13821   char *new = alloca (len+1);
13822
13823   if (after)
13824     {
13825       memcpy (new, string, string_len);
13826       memcpy (&new [string_len], old, old_len);
13827     }
13828   else
13829     {
13830       memcpy (new, old, old_len);
13831       memcpy (&new [old_len], string, string_len);
13832     }
13833   new [len] = '\0';
13834   return build_string (len, new);
13835 }
13836
13837 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13838    new STRING_CST on success, NULL_TREE on failure.  */
13839
13840 static tree
13841 merge_string_cste (tree op1, tree op2, int after)
13842 {
13843   /* Handle two string constants right away.  */
13844   if (TREE_CODE (op2) == STRING_CST)
13845     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13846                                  TREE_STRING_LENGTH (op2), after);
13847
13848   /* Reasonable integer constant can be treated right away.  */
13849   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13850     {
13851       static const char *const boolean_true = "true";
13852       static const char *const boolean_false = "false";
13853       static const char *const null_pointer = "null";
13854       char ch[4];
13855       const char *string;
13856
13857       if (op2 == boolean_true_node)
13858         string = boolean_true;
13859       else if (op2 == boolean_false_node)
13860         string = boolean_false;
13861       else if (op2 == null_pointer_node)
13862         /* FIXME: null is not a compile-time constant, so it is only safe to
13863            merge if the overall expression is non-constant. However, this
13864            code always merges without checking the overall expression.  */
13865         string = null_pointer;
13866       else if (TREE_TYPE (op2) == char_type_node)
13867         {
13868           /* Convert the character into UTF-8.  */
13869           unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13870           unsigned char *p = (unsigned char *) ch;
13871           if (0x01 <= c && c <= 0x7f)
13872             *p++ = (unsigned char) c;
13873           else if (c < 0x7ff)
13874             {
13875               *p++ = (unsigned char) (c >> 6 | 0xc0);
13876               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13877             }
13878           else
13879             {
13880               *p++ = (unsigned char) (c >> 12 | 0xe0);
13881               *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13882               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13883             }
13884           *p = '\0';
13885
13886           string = ch;
13887         }
13888       else
13889         string = string_convert_int_cst (op2);
13890
13891       return do_merge_string_cste (op1, string, strlen (string), after);
13892     }
13893   return NULL_TREE;
13894 }
13895
13896 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13897    has to be a STRING_CST and the other part must be a STRING_CST or a
13898    INTEGRAL constant. Return a new STRING_CST if the operation
13899    succeed, NULL_TREE otherwise.
13900
13901    If the case we want to optimize for space, we might want to return
13902    NULL_TREE for each invocation of this routine. FIXME */
13903
13904 static tree
13905 string_constant_concatenation (tree op1, tree op2)
13906 {
13907   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13908     {
13909       tree string, rest;
13910       int invert;
13911
13912       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13913       rest   = (string == op1 ? op2 : op1);
13914       invert = (string == op1 ? 0 : 1 );
13915
13916       /* Walk REST, only if it looks reasonable */
13917       if (TREE_CODE (rest) != STRING_CST
13918           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13919           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13920           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13921         {
13922           rest = java_complete_tree (rest);
13923           if (rest == error_mark_node)
13924             return error_mark_node;
13925           rest = fold (rest);
13926         }
13927       return merge_string_cste (string, rest, invert);
13928     }
13929   return NULL_TREE;
13930 }
13931
13932 /* Implement the `+' operator. Does static optimization if possible,
13933    otherwise create (if necessary) and append elements to a
13934    StringBuffer. The StringBuffer will be carried around until it is
13935    used for a function call or an assignment. Then toString() will be
13936    called on it to turn it into a String object. */
13937
13938 static tree
13939 build_string_concatenation (tree op1, tree op2)
13940 {
13941   tree result;
13942   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13943
13944   if (flag_emit_xref)
13945     return build (PLUS_EXPR, string_type_node, op1, op2);
13946
13947   /* Try to do some static optimization */
13948   if ((result = string_constant_concatenation (op1, op2)))
13949     return result;
13950
13951   /* Discard empty strings on either side of the expression */
13952   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13953     {
13954       op1 = op2;
13955       op2 = NULL_TREE;
13956     }
13957   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13958     op2 = NULL_TREE;
13959
13960   /* If operands are string constant, turn then into object references */
13961   if (TREE_CODE (op1) == STRING_CST)
13962     op1 = patch_string_cst (op1);
13963   if (op2 && TREE_CODE (op2) == STRING_CST)
13964     op2 = patch_string_cst (op2);
13965
13966   /* If either one of the constant is null and the other non null
13967      operand is a String constant, return it. */
13968   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13969     return op1;
13970
13971   /* If OP1 isn't already a StringBuffer, create and
13972      initialize a new one */
13973   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13974     {
13975       /* Two solutions here:
13976          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13977          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13978       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13979         op1 = BUILD_STRING_BUFFER (op1);
13980       else
13981         {
13982           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13983           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13984         }
13985     }
13986
13987   if (op2)
13988     {
13989       /* OP1 is no longer the last node holding a crafted StringBuffer */
13990       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13991       /* Create a node for `{new...,xxx}.append (op2)' */
13992       if (op2)
13993         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13994     }
13995
13996   /* Mark the last node holding a crafted StringBuffer */
13997   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13998
13999   TREE_SIDE_EFFECTS (op1) = side_effects;
14000   return op1;
14001 }
14002
14003 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
14004    StringBuffer. If no string were found to be patched, return
14005    NULL. */
14006
14007 static tree
14008 patch_string (tree node)
14009 {
14010   if (node == error_mark_node)
14011     return error_mark_node;
14012   if (TREE_CODE (node) == STRING_CST)
14013     return patch_string_cst (node);
14014   else if (IS_CRAFTED_STRING_BUFFER_P (node))
14015     {
14016       int saved = ctxp->explicit_constructor_p;
14017       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
14018       tree ret;
14019       /* Temporary disable forbid the use of `this'. */
14020       ctxp->explicit_constructor_p = 0;
14021       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
14022       /* String concatenation arguments must be evaluated in order too. */
14023       ret = force_evaluation_order (ret);
14024       /* Restore it at its previous value */
14025       ctxp->explicit_constructor_p = saved;
14026       return ret;
14027     }
14028   return NULL_TREE;
14029 }
14030
14031 /* Build the internal representation of a string constant.  */
14032
14033 static tree
14034 patch_string_cst (tree node)
14035 {
14036   int location;
14037   if (! flag_emit_class_files)
14038     {
14039       node = get_identifier (TREE_STRING_POINTER (node));
14040       location = alloc_name_constant (CONSTANT_String, node);
14041       node = build_ref_from_constant_pool (location);
14042     }
14043   TREE_TYPE (node) = string_ptr_type_node;
14044   TREE_CONSTANT (node) = 1;
14045   return node;
14046 }
14047
14048 /* Build an incomplete unary operator expression. */
14049
14050 static tree
14051 build_unaryop (int op_token, int op_location, tree op1)
14052 {
14053   enum tree_code op;
14054   tree unaryop;
14055   switch (op_token)
14056     {
14057     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
14058     case MINUS_TK: op = NEGATE_EXPR; break;
14059     case NEG_TK: op = TRUTH_NOT_EXPR; break;
14060     case NOT_TK: op = BIT_NOT_EXPR; break;
14061     default: abort ();
14062     }
14063
14064   unaryop = build1 (op, NULL_TREE, op1);
14065   TREE_SIDE_EFFECTS (unaryop) = 1;
14066   /* Store the location of the operator, for better error report. The
14067      string of the operator will be rebuild based on the OP value. */
14068   EXPR_WFL_LINECOL (unaryop) = op_location;
14069   return unaryop;
14070 }
14071
14072 /* Special case for the ++/-- operators, since they require an extra
14073    argument to build, which is set to NULL and patched
14074    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
14075
14076 static tree
14077 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
14078 {
14079   static const enum tree_code lookup [2][2] =
14080     {
14081       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
14082       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
14083     };
14084   tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
14085                      NULL_TREE, op1, NULL_TREE);
14086   TREE_SIDE_EFFECTS (node) = 1;
14087   /* Store the location of the operator, for better error report. The
14088      string of the operator will be rebuild based on the OP value. */
14089   EXPR_WFL_LINECOL (node) = op_location;
14090   return node;
14091 }
14092
14093 /* Build an incomplete cast operator, based on the use of the
14094    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
14095    set. java_complete_tree is trained to walk a CONVERT_EXPR even
14096    though its type is already set.  */
14097
14098 static tree
14099 build_cast (int location, tree type, tree exp)
14100 {
14101   tree node = build1 (CONVERT_EXPR, type, exp);
14102   EXPR_WFL_LINECOL (node) = location;
14103   return node;
14104 }
14105
14106 /* Build an incomplete class reference operator.  */
14107 static tree
14108 build_incomplete_class_ref (int location, tree class_name)
14109 {
14110   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
14111   EXPR_WFL_LINECOL (node) = location;
14112   return node;
14113 }
14114
14115 /* Complete an incomplete class reference operator.  */
14116 static tree
14117 patch_incomplete_class_ref (tree node)
14118 {
14119   tree type = TREE_OPERAND (node, 0);
14120   tree ref_type;
14121
14122   if (!(ref_type = resolve_type_during_patch (type)))
14123     return error_mark_node;
14124
14125   /* Generate the synthetic static method `class$'.  (Previously we
14126      deferred this, causing different method tables to be emitted
14127      for native code and bytecode.)  */
14128   if (!TYPE_DOT_CLASS (current_class))
14129       build_dot_class_method (current_class);
14130
14131   /* If we're not emitting class files and we know ref_type is a
14132      compiled class, build a direct reference.  */
14133   if ((! flag_emit_class_files && is_compiled_class (ref_type))
14134       || JPRIMITIVE_TYPE_P (ref_type)
14135       || TREE_CODE (ref_type) == VOID_TYPE)
14136     {
14137       tree dot = build_class_ref (ref_type);
14138       /* A class referenced by `foo.class' is initialized.  */
14139       if (!flag_emit_class_files)
14140        dot = build_class_init (ref_type, dot);
14141       return java_complete_tree (dot);
14142     }
14143
14144   /* If we're emitting class files and we have to deal with non
14145      primitive types, we invoke the synthetic static method `class$'.  */
14146   ref_type = build_dot_class_method_invocation (ref_type);
14147   return java_complete_tree (ref_type);
14148 }
14149
14150 /* 15.14 Unary operators. We return error_mark_node in case of error,
14151    but preserve the type of NODE if the type is fixed.  */
14152
14153 static tree
14154 patch_unaryop (tree node, tree wfl_op)
14155 {
14156   tree op = TREE_OPERAND (node, 0);
14157   tree op_type = TREE_TYPE (op);
14158   tree prom_type = NULL_TREE, value, decl;
14159   int outer_field_flag = 0;
14160   int code = TREE_CODE (node);
14161   int error_found = 0;
14162
14163   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14164
14165   switch (code)
14166     {
14167       /* 15.13.2 Postfix Increment Operator ++ */
14168     case POSTINCREMENT_EXPR:
14169       /* 15.13.3 Postfix Increment Operator -- */
14170     case POSTDECREMENT_EXPR:
14171       /* 15.14.1 Prefix Increment Operator ++ */
14172     case PREINCREMENT_EXPR:
14173       /* 15.14.2 Prefix Decrement Operator -- */
14174     case PREDECREMENT_EXPR:
14175       op = decl = strip_out_static_field_access_decl (op);
14176       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14177       /* We might be trying to change an outer field accessed using
14178          access method. */
14179       if (outer_field_flag)
14180         {
14181           /* Retrieve the decl of the field we're trying to access. We
14182              do that by first retrieving the function we would call to
14183              access the field. It has been already verified that this
14184              field isn't final */
14185           if (flag_emit_class_files)
14186             decl = TREE_OPERAND (op, 0);
14187           else
14188             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14189           decl = DECL_FUNCTION_ACCESS_DECL (decl);
14190         }
14191       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14192       else if (!JDECL_P (decl)
14193           && TREE_CODE (decl) != COMPONENT_REF
14194           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14195           && TREE_CODE (decl) != INDIRECT_REF
14196           && !(TREE_CODE (decl) == COMPOUND_EXPR
14197                && TREE_OPERAND (decl, 1)
14198                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14199         {
14200           TREE_TYPE (node) = error_mark_node;
14201           error_found = 1;
14202         }
14203
14204       /* From now on, we know that op if a variable and that it has a
14205          valid wfl. We use wfl_op to locate errors related to the
14206          ++/-- operand. */
14207       if (!JNUMERIC_TYPE_P (op_type))
14208         {
14209           parse_error_context
14210             (wfl_op, "Invalid argument type `%s' to `%s'",
14211              lang_printable_name (op_type, 0), operator_string (node));
14212           TREE_TYPE (node) = error_mark_node;
14213           error_found = 1;
14214         }
14215       else
14216         {
14217           /* Before the addition, binary numeric promotion is performed on
14218              both operands, if really necessary */
14219           if (JINTEGRAL_TYPE_P (op_type))
14220             {
14221               value = build_int_2 (1, 0);
14222               TREE_TYPE (value) = TREE_TYPE (node) = op_type;
14223             }
14224           else
14225             {
14226               value = build_int_2 (1, 0);
14227               TREE_TYPE (node) =
14228                 binary_numeric_promotion (op_type,
14229                                           TREE_TYPE (value), &op, &value);
14230             }
14231
14232           /* We remember we might be accessing an outer field */
14233           if (outer_field_flag)
14234             {
14235               /* We re-generate an access to the field */
14236               value = build (PLUS_EXPR, TREE_TYPE (op),
14237                              build_outer_field_access (wfl_op, decl), value);
14238
14239               /* And we patch the original access$() into a write
14240                  with plus_op as a rhs */
14241               return outer_field_access_fix (node, op, value);
14242             }
14243
14244           /* And write back into the node. */
14245           TREE_OPERAND (node, 0) = op;
14246           TREE_OPERAND (node, 1) = value;
14247           /* Convert the overall back into its original type, if
14248              necessary, and return */
14249           if (JINTEGRAL_TYPE_P (op_type))
14250             return fold (node);
14251           else
14252             return fold (convert (op_type, node));
14253         }
14254       break;
14255
14256       /* 15.14.3 Unary Plus Operator + */
14257     case UNARY_PLUS_EXPR:
14258       /* 15.14.4 Unary Minus Operator - */
14259     case NEGATE_EXPR:
14260       if (!JNUMERIC_TYPE_P (op_type))
14261         {
14262           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14263           TREE_TYPE (node) = error_mark_node;
14264           error_found = 1;
14265         }
14266       /* Unary numeric promotion is performed on operand */
14267       else
14268         {
14269           op = do_unary_numeric_promotion (op);
14270           prom_type = TREE_TYPE (op);
14271           if (code == UNARY_PLUS_EXPR)
14272             return fold (op);
14273         }
14274       break;
14275
14276       /* 15.14.5 Bitwise Complement Operator ~ */
14277     case BIT_NOT_EXPR:
14278       if (!JINTEGRAL_TYPE_P (op_type))
14279         {
14280           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14281           TREE_TYPE (node) = error_mark_node;
14282           error_found = 1;
14283         }
14284       else
14285         {
14286           op = do_unary_numeric_promotion (op);
14287           prom_type = TREE_TYPE (op);
14288         }
14289       break;
14290
14291       /* 15.14.6 Logical Complement Operator ! */
14292     case TRUTH_NOT_EXPR:
14293       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14294         {
14295           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14296           /* But the type is known. We will report an error if further
14297              attempt of a assignment is made with this rhs */
14298           TREE_TYPE (node) = boolean_type_node;
14299           error_found = 1;
14300         }
14301       else
14302         prom_type = boolean_type_node;
14303       break;
14304
14305       /* 15.15 Cast Expression */
14306     case CONVERT_EXPR:
14307       value = patch_cast (node, wfl_operator);
14308       if (value == error_mark_node)
14309         {
14310           /* If this cast is part of an assignment, we tell the code
14311              that deals with it not to complain about a mismatch,
14312              because things have been cast, anyways */
14313           TREE_TYPE (node) = error_mark_node;
14314           error_found = 1;
14315         }
14316       else
14317         {
14318           value = fold (value);
14319           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14320           return value;
14321         }
14322       break;
14323     }
14324
14325   if (error_found)
14326     return error_mark_node;
14327
14328   /* There are cases where node has been replaced by something else
14329      and we don't end up returning here: UNARY_PLUS_EXPR,
14330      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14331   TREE_OPERAND (node, 0) = fold (op);
14332   TREE_TYPE (node) = prom_type;
14333   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14334   return fold (node);
14335 }
14336
14337 /* Generic type resolution that sometimes takes place during node
14338    patching. Returned the resolved type or generate an error
14339    message. Return the resolved type or NULL_TREE.  */
14340
14341 static tree
14342 resolve_type_during_patch (tree type)
14343 {
14344   if (unresolved_type_p (type, NULL))
14345     {
14346       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14347       if (!type_decl)
14348         {
14349           parse_error_context (type,
14350                                "Class `%s' not found in type declaration",
14351                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14352           return NULL_TREE;
14353         }
14354
14355       check_deprecation (type, type_decl);
14356
14357       return TREE_TYPE (type_decl);
14358     }
14359   return type;
14360 }
14361
14362 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14363    found. Otherwise NODE or something meant to replace it is returned.  */
14364
14365 static tree
14366 patch_cast (tree node, tree wfl_op)
14367 {
14368   tree op = TREE_OPERAND (node, 0);
14369   tree cast_type = TREE_TYPE (node);
14370   tree patched, op_type;
14371   char *t1;
14372
14373   /* Some string patching might be necessary at this stage */
14374   if ((patched = patch_string (op)))
14375     TREE_OPERAND (node, 0) = op = patched;
14376   op_type = TREE_TYPE (op);
14377
14378   /* First resolve OP_TYPE if unresolved */
14379   if (!(cast_type = resolve_type_during_patch (cast_type)))
14380     return error_mark_node;
14381
14382   /* Check on cast that are proven correct at compile time */
14383   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14384     {
14385       /* Same type */
14386       if (cast_type == op_type)
14387         return node;
14388
14389       /* A narrowing conversion from a floating-point number to an
14390          integral type requires special handling (5.1.3).  */
14391       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14392         if (cast_type != long_type_node)
14393           op = convert (integer_type_node, op);
14394
14395       /* Try widening/narrowing convertion.  Potentially, things need
14396          to be worked out in gcc so we implement the extreme cases
14397          correctly.  fold_convert() needs to be fixed.  */
14398       return convert (cast_type, op);
14399     }
14400
14401   /* It's also valid to cast a boolean into a boolean */
14402   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14403     return node;
14404
14405   /* null can be casted to references */
14406   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14407     return build_null_of_type (cast_type);
14408
14409   /* The remaining legal casts involve conversion between reference
14410      types. Check for their compile time correctness. */
14411   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14412       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14413     {
14414       TREE_TYPE (node) = promote_type (cast_type);
14415       /* Now, the case can be determined correct at compile time if
14416          OP_TYPE can be converted into CAST_TYPE by assignment
14417          conversion (5.2) */
14418
14419       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14420         {
14421           TREE_SET_CODE (node, NOP_EXPR);
14422           return node;
14423         }
14424
14425       if (flag_emit_class_files)
14426         {
14427           TREE_SET_CODE (node, CONVERT_EXPR);
14428           return node;
14429         }
14430
14431       /* The cast requires a run-time check */
14432       return build (CALL_EXPR, promote_type (cast_type),
14433                     build_address_of (soft_checkcast_node),
14434                     tree_cons (NULL_TREE, build_class_ref (cast_type),
14435                                build_tree_list (NULL_TREE, op)),
14436                     NULL_TREE);
14437     }
14438
14439   /* Any other casts are proven incorrect at compile time */
14440   t1 = xstrdup (lang_printable_name (op_type, 0));
14441   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14442                        t1, lang_printable_name (cast_type, 0));
14443   free (t1);
14444   return error_mark_node;
14445 }
14446
14447 /* Build a null constant and give it the type TYPE.  */
14448
14449 static tree
14450 build_null_of_type (tree type)
14451 {
14452   tree node = build_int_2 (0, 0);
14453   TREE_TYPE (node) = promote_type (type);
14454   return node;
14455 }
14456
14457 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14458    a list of indices. */
14459 static tree
14460 build_array_ref (int location, tree array, tree index)
14461 {
14462   tree node = build (ARRAY_REF, NULL_TREE, array, index);
14463   EXPR_WFL_LINECOL (node) = location;
14464   return node;
14465 }
14466
14467 /* 15.12 Array Access Expression */
14468
14469 static tree
14470 patch_array_ref (tree node)
14471 {
14472   tree array = TREE_OPERAND (node, 0);
14473   tree array_type  = TREE_TYPE (array);
14474   tree index = TREE_OPERAND (node, 1);
14475   tree index_type = TREE_TYPE (index);
14476   int error_found = 0;
14477
14478   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14479
14480   if (TREE_CODE (array_type) == POINTER_TYPE)
14481     array_type = TREE_TYPE (array_type);
14482
14483   /* The array reference must be an array */
14484   if (!TYPE_ARRAY_P (array_type))
14485     {
14486       parse_error_context
14487         (wfl_operator,
14488          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14489          lang_printable_name (array_type, 0));
14490       TREE_TYPE (node) = error_mark_node;
14491       error_found = 1;
14492     }
14493
14494   /* The array index undergoes unary numeric promotion. The promoted
14495      type must be int */
14496   index = do_unary_numeric_promotion (index);
14497   if (TREE_TYPE (index) != int_type_node)
14498     {
14499       if (valid_cast_to_p (index_type, int_type_node))
14500         parse_error_context (wfl_operator,
14501    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14502                              lang_printable_name (index_type, 0));
14503       else
14504         parse_error_context (wfl_operator,
14505           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14506                              lang_printable_name (index_type, 0));
14507       TREE_TYPE (node) = error_mark_node;
14508       error_found = 1;
14509     }
14510
14511   if (error_found)
14512     return error_mark_node;
14513
14514   array_type = TYPE_ARRAY_ELEMENT (array_type);
14515
14516   if (flag_emit_class_files || flag_emit_xref)
14517     {
14518       TREE_OPERAND (node, 0) = array;
14519       TREE_OPERAND (node, 1) = index;
14520     }
14521   else
14522     node = build_java_arrayaccess (array, array_type, index);
14523   TREE_TYPE (node) = array_type;
14524   return node;
14525 }
14526
14527 /* 15.9 Array Creation Expressions */
14528
14529 static tree
14530 build_newarray_node (tree type, tree dims, int extra_dims)
14531 {
14532   tree node =
14533     build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
14534            build_int_2 (extra_dims, 0));
14535   return node;
14536 }
14537
14538 static tree
14539 patch_newarray (tree node)
14540 {
14541   tree type = TREE_OPERAND (node, 0);
14542   tree dims = TREE_OPERAND (node, 1);
14543   tree cdim, array_type;
14544   int error_found = 0;
14545   int ndims = 0;
14546   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14547
14548   /* Dimension types are verified. It's better for the types to be
14549      verified in order. */
14550   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14551     {
14552       int dim_error = 0;
14553       tree dim = TREE_VALUE (cdim);
14554
14555       /* Dim might have been saved during its evaluation */
14556       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14557
14558       /* The type of each specified dimension must be an integral type. */
14559       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14560         dim_error = 1;
14561
14562       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14563          promoted type must be int. */
14564       else
14565         {
14566           dim = do_unary_numeric_promotion (dim);
14567           if (TREE_TYPE (dim) != int_type_node)
14568             dim_error = 1;
14569         }
14570
14571       /* Report errors on types here */
14572       if (dim_error)
14573         {
14574           parse_error_context
14575             (TREE_PURPOSE (cdim),
14576              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14577              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14578               "Explicit cast needed to" : "Can't"),
14579              lang_printable_name (TREE_TYPE (dim), 0));
14580           error_found = 1;
14581         }
14582
14583       TREE_PURPOSE (cdim) = NULL_TREE;
14584     }
14585
14586   /* Resolve array base type if unresolved */
14587   if (!(type = resolve_type_during_patch (type)))
14588     error_found = 1;
14589
14590   if (error_found)
14591     {
14592       /* We don't want further evaluation of this bogus array creation
14593          operation */
14594       TREE_TYPE (node) = error_mark_node;
14595       return error_mark_node;
14596     }
14597
14598   /* Set array_type to the actual (promoted) array type of the result. */
14599   if (TREE_CODE (type) == RECORD_TYPE)
14600     type = build_pointer_type (type);
14601   while (--xdims >= 0)
14602     {
14603       type = promote_type (build_java_array_type (type, -1));
14604     }
14605   dims = nreverse (dims);
14606   array_type = type;
14607   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14608     {
14609       type = array_type;
14610       array_type
14611         = build_java_array_type (type,
14612                                  TREE_CODE (cdim) == INTEGER_CST
14613                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14614                                  : -1);
14615       array_type = promote_type (array_type);
14616     }
14617   dims = nreverse (dims);
14618
14619   /* The node is transformed into a function call. Things are done
14620      differently according to the number of dimensions. If the number
14621      of dimension is equal to 1, then the nature of the base type
14622      (primitive or not) matters. */
14623   if (ndims == 1)
14624     return build_new_array (type, TREE_VALUE (dims));
14625
14626   /* Can't reuse what's already written in expr.c because it uses the
14627      JVM stack representation. Provide a build_multianewarray. FIXME */
14628   return build (CALL_EXPR, array_type,
14629                 build_address_of (soft_multianewarray_node),
14630                 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
14631                            tree_cons (NULL_TREE,
14632                                       build_int_2 (ndims, 0), dims )),
14633                 NULL_TREE);
14634 }
14635
14636 /* 10.6 Array initializer.  */
14637
14638 /* Build a wfl for array element that don't have one, so we can
14639    pin-point errors.  */
14640
14641 static tree
14642 maybe_build_array_element_wfl (tree node)
14643 {
14644   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14645     return build_expr_wfl (NULL_TREE, ctxp->filename,
14646                            ctxp->elc.line, ctxp->elc.prev_col);
14647   else
14648     return NULL_TREE;
14649 }
14650
14651 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14652    identification of initialized arrays easier to detect during walk
14653    and expansion.  */
14654
14655 static tree
14656 build_new_array_init (int location, tree values)
14657 {
14658   tree constructor = build_constructor (NULL_TREE, values);
14659   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14660   EXPR_WFL_LINECOL (to_return) = location;
14661   return to_return;
14662 }
14663
14664 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14665    occurred.  Otherwise return NODE after having set its type
14666    appropriately.  */
14667
14668 static tree
14669 patch_new_array_init (tree type, tree node)
14670 {
14671   int error_seen = 0;
14672   tree current, element_type;
14673   HOST_WIDE_INT length;
14674   int all_constant = 1;
14675   tree init = TREE_OPERAND (node, 0);
14676
14677   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14678     {
14679       parse_error_context (node,
14680                            "Invalid array initializer for non-array type `%s'",
14681                            lang_printable_name (type, 1));
14682       return error_mark_node;
14683     }
14684   type = TREE_TYPE (type);
14685   element_type = TYPE_ARRAY_ELEMENT (type);
14686
14687   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14688
14689   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14690        current;  length++, current = TREE_CHAIN (current))
14691     {
14692       tree elt = TREE_VALUE (current);
14693       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14694         {
14695           error_seen |= array_constructor_check_entry (element_type, current);
14696           elt = TREE_VALUE (current);
14697           /* When compiling to native code, STRING_CST is converted to
14698              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14699           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14700             all_constant = 0;
14701         }
14702       else
14703         {
14704           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14705           TREE_PURPOSE (current) = NULL_TREE;
14706           all_constant = 0;
14707         }
14708       if (elt && TREE_CODE (elt) == TREE_LIST
14709           && TREE_VALUE (elt) == error_mark_node)
14710         error_seen = 1;
14711     }
14712
14713   if (error_seen)
14714     return error_mark_node;
14715
14716   /* Create a new type. We can't reuse the one we have here by
14717      patching its dimension because it originally is of dimension -1
14718      hence reused by gcc. This would prevent triangular arrays. */
14719   type = build_java_array_type (element_type, length);
14720   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14721   TREE_TYPE (node) = promote_type (type);
14722   TREE_CONSTANT (init) = all_constant;
14723   TREE_CONSTANT (node) = all_constant;
14724   return node;
14725 }
14726
14727 /* Verify that one entry of the initializer element list can be
14728    assigned to the array base type. Report 1 if an error occurred, 0
14729    otherwise.  */
14730
14731 static int
14732 array_constructor_check_entry (tree type, tree entry)
14733 {
14734   char *array_type_string = NULL;       /* For error reports */
14735   tree value, type_value, new_value, wfl_value, patched;
14736   int error_seen = 0;
14737
14738   new_value = NULL_TREE;
14739   wfl_value = TREE_VALUE (entry);
14740
14741   value = java_complete_tree (TREE_VALUE (entry));
14742   /* patch_string return error_mark_node if arg is error_mark_node */
14743   if ((patched = patch_string (value)))
14744     value = patched;
14745   if (value == error_mark_node)
14746     return 1;
14747
14748   type_value = TREE_TYPE (value);
14749
14750   /* At anytime, try_builtin_assignconv can report a warning on
14751      constant overflow during narrowing. */
14752   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14753   new_value = try_builtin_assignconv (wfl_operator, type, value);
14754   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14755     type_value = promote_type (type);
14756
14757   /* Check and report errors */
14758   if (!new_value)
14759     {
14760       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14761                    "Can't" : "Explicit cast needed to");
14762       if (!array_type_string)
14763         array_type_string = xstrdup (lang_printable_name (type, 1));
14764       parse_error_context
14765         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14766          msg, lang_printable_name (type_value, 1), array_type_string);
14767       error_seen = 1;
14768     }
14769
14770   if (new_value)
14771     TREE_VALUE (entry) = new_value;
14772
14773   if (array_type_string)
14774     free (array_type_string);
14775
14776   TREE_PURPOSE (entry) = NULL_TREE;
14777   return error_seen;
14778 }
14779
14780 static tree
14781 build_this (int location)
14782 {
14783   tree node = build_wfl_node (this_identifier_node);
14784   TREE_SET_CODE (node, THIS_EXPR);
14785   EXPR_WFL_LINECOL (node) = location;
14786   return node;
14787 }
14788
14789 /* 14.15 The return statement. It builds a modify expression that
14790    assigns the returned value to the RESULT_DECL that hold the value
14791    to be returned. */
14792
14793 static tree
14794 build_return (int location, tree op)
14795 {
14796   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14797   EXPR_WFL_LINECOL (node) = location;
14798   node = build_debugable_stmt (location, node);
14799   return node;
14800 }
14801
14802 static tree
14803 patch_return (tree node)
14804 {
14805   tree return_exp = TREE_OPERAND (node, 0);
14806   tree meth = current_function_decl;
14807   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14808   int error_found = 0;
14809
14810   TREE_TYPE (node) = error_mark_node;
14811   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14812
14813   /* It's invalid to have a return value within a function that is
14814      declared with the keyword void or that is a constructor */
14815   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14816     error_found = 1;
14817
14818   /* It's invalid to use a return statement in a static block */
14819   if (DECL_CLINIT_P (current_function_decl))
14820     error_found = 1;
14821
14822   /* It's invalid to have a no return value within a function that
14823      isn't declared with the keyword `void' */
14824   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14825     error_found = 2;
14826
14827   if (DECL_INSTINIT_P (current_function_decl))
14828     error_found = 1;
14829
14830   if (error_found)
14831     {
14832       if (DECL_INSTINIT_P (current_function_decl))
14833         parse_error_context (wfl_operator,
14834                              "`return' inside instance initializer");
14835
14836       else if (DECL_CLINIT_P (current_function_decl))
14837         parse_error_context (wfl_operator,
14838                              "`return' inside static initializer");
14839
14840       else if (!DECL_CONSTRUCTOR_P (meth))
14841         {
14842           char *t = xstrdup (lang_printable_name (mtype, 0));
14843           parse_error_context (wfl_operator,
14844                                "`return' with%s value from `%s %s'",
14845                                (error_found == 1 ? "" : "out"),
14846                                t, lang_printable_name (meth, 0));
14847           free (t);
14848         }
14849       else
14850         parse_error_context (wfl_operator,
14851                              "`return' with value from constructor `%s'",
14852                              lang_printable_name (meth, 0));
14853       return error_mark_node;
14854     }
14855
14856   /* If we have a return_exp, build a modify expression and expand
14857      it. Note: at that point, the assignment is declared valid, but we
14858      may want to carry some more hacks */
14859   if (return_exp)
14860     {
14861       tree exp = java_complete_tree (return_exp);
14862       tree modify, patched;
14863
14864       if ((patched = patch_string (exp)))
14865         exp = patched;
14866
14867       modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14868       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14869       modify = java_complete_tree (modify);
14870
14871       if (modify != error_mark_node)
14872         {
14873           TREE_SIDE_EFFECTS (modify) = 1;
14874           TREE_OPERAND (node, 0) = modify;
14875         }
14876       else
14877         return error_mark_node;
14878     }
14879   TREE_TYPE (node) = void_type_node;
14880   TREE_SIDE_EFFECTS (node) = 1;
14881   return node;
14882 }
14883
14884 /* 14.8 The if Statement */
14885
14886 static tree
14887 build_if_else_statement (int location, tree expression, tree if_body,
14888                          tree else_body)
14889 {
14890   tree node;
14891   if (!else_body)
14892     else_body = empty_stmt_node;
14893   node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14894   EXPR_WFL_LINECOL (node) = location;
14895   node = build_debugable_stmt (location, node);
14896   return node;
14897 }
14898
14899 static tree
14900 patch_if_else_statement (tree node)
14901 {
14902   tree expression = TREE_OPERAND (node, 0);
14903   int can_complete_normally
14904     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14905        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14906
14907   TREE_TYPE (node) = error_mark_node;
14908   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14909
14910   /* The type of expression must be boolean */
14911   if (TREE_TYPE (expression) != boolean_type_node
14912       && TREE_TYPE (expression) != promoted_boolean_type_node)
14913     {
14914       parse_error_context
14915         (wfl_operator,
14916          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14917          lang_printable_name (TREE_TYPE (expression), 0));
14918       return error_mark_node;
14919     }
14920
14921   if (TREE_CODE (expression) == INTEGER_CST)
14922     {
14923       if (integer_zerop (expression))
14924         node = TREE_OPERAND (node, 2);
14925       else
14926         node = TREE_OPERAND (node, 1);
14927       if (CAN_COMPLETE_NORMALLY (node) != can_complete_normally)
14928         {
14929           node = build (COMPOUND_EXPR, void_type_node, node, empty_stmt_node);
14930           CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14931         }
14932       return node;
14933     }
14934   TREE_TYPE (node) = void_type_node;
14935   TREE_SIDE_EFFECTS (node) = 1;
14936   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14937   return node;
14938 }
14939
14940 /* 14.6 Labeled Statements */
14941
14942 /* Action taken when a lableled statement is parsed. a new
14943    LABELED_BLOCK_EXPR is created. No statement is attached to the
14944    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14945
14946 static tree
14947 build_labeled_block (int location, tree label)
14948 {
14949   tree label_name ;
14950   tree label_decl, node;
14951   if (label == NULL_TREE || label == continue_identifier_node)
14952     label_name = label;
14953   else
14954     {
14955       label_name = merge_qualified_name (label_id, label);
14956       /* Issue an error if we try to reuse a label that was previously
14957          declared */
14958       if (IDENTIFIER_LOCAL_VALUE (label_name))
14959         {
14960           EXPR_WFL_LINECOL (wfl_operator) = location;
14961           parse_error_context (wfl_operator,
14962             "Declaration of `%s' shadows a previous label declaration",
14963                                IDENTIFIER_POINTER (label));
14964           EXPR_WFL_LINECOL (wfl_operator) =
14965             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14966           parse_error_context (wfl_operator,
14967             "This is the location of the previous declaration of label `%s'",
14968                                IDENTIFIER_POINTER (label));
14969           java_error_count--;
14970         }
14971     }
14972
14973   label_decl = create_label_decl (label_name);
14974   node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14975   EXPR_WFL_LINECOL (node) = location;
14976   TREE_SIDE_EFFECTS (node) = 1;
14977   return node;
14978 }
14979
14980 /* A labeled statement LBE is attached a statement.  */
14981
14982 static tree
14983 finish_labeled_statement (tree lbe, /* Labeled block expr */
14984                           tree statement)
14985 {
14986   /* In anyways, tie the loop to its statement */
14987   LABELED_BLOCK_BODY (lbe) = statement;
14988   pop_labeled_block ();
14989   POP_LABELED_BLOCK ();
14990   return lbe;
14991 }
14992
14993 /* 14.10, 14.11, 14.12 Loop Statements */
14994
14995 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14996    list. */
14997
14998 static tree
14999 build_new_loop (tree loop_body)
15000 {
15001   tree loop =  build (LOOP_EXPR, NULL_TREE, loop_body);
15002   TREE_SIDE_EFFECTS (loop) = 1;
15003   PUSH_LOOP (loop);
15004   return loop;
15005 }
15006
15007 /* Create a loop body according to the following structure:
15008      COMPOUND_EXPR
15009        COMPOUND_EXPR            (loop main body)
15010          EXIT_EXPR              (this order is for while/for loops.
15011          LABELED_BLOCK_EXPR      the order is reversed for do loops)
15012            LABEL_DECL           (a continue occurring here branches at the
15013            BODY                  end of this labeled block)
15014        INCREMENT                (if any)
15015
15016   REVERSED, if nonzero, tells that the loop condition expr comes
15017   after the body, like in the do-while loop.
15018
15019   To obtain a loop, the loop body structure described above is
15020   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
15021
15022    LABELED_BLOCK_EXPR
15023      LABEL_DECL                   (use this label to exit the loop)
15024      LOOP_EXPR
15025        <structure described above> */
15026
15027 static tree
15028 build_loop_body (int location, tree condition, int reversed)
15029 {
15030   tree first, second, body;
15031
15032   condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
15033   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
15034   condition = build_debugable_stmt (location, condition);
15035   TREE_SIDE_EFFECTS (condition) = 1;
15036
15037   body = build_labeled_block (0, continue_identifier_node);
15038   first = (reversed ? body : condition);
15039   second = (reversed ? condition : body);
15040   return
15041     build (COMPOUND_EXPR, NULL_TREE,
15042            build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
15043 }
15044
15045 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
15046    their order) on the current loop. Unlink the current loop from the
15047    loop list.  */
15048
15049 static tree
15050 finish_loop_body (int location, tree condition, tree body, int reversed)
15051 {
15052   tree to_return = ctxp->current_loop;
15053   tree loop_body = LOOP_EXPR_BODY (to_return);
15054   if (condition)
15055     {
15056       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
15057       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
15058          The real EXIT_EXPR is one operand further. */
15059       EXPR_WFL_LINECOL (cnode) = location;
15060       /* This one is for accurate error reports */
15061       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
15062       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
15063     }
15064   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
15065   POP_LOOP ();
15066   return to_return;
15067 }
15068
15069 /* Tailored version of finish_loop_body for FOR loops, when FOR
15070    loops feature the condition part */
15071
15072 static tree
15073 finish_for_loop (int location, tree condition, tree update, tree body)
15074 {
15075   /* Put the condition and the loop body in place */
15076   tree loop = finish_loop_body (location, condition, body, 0);
15077   /* LOOP is the current loop which has been now popped of the loop
15078      stack.  Mark the update block as reachable and install it.  We do
15079      this because the (current interpretation of the) JLS requires
15080      that the update expression be considered reachable even if the
15081      for loop's body doesn't complete normally.  */
15082   if (update != NULL_TREE && update != empty_stmt_node)
15083     {
15084       tree up2 = update;
15085       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
15086         up2 = EXPR_WFL_NODE (up2);
15087       /* It is possible for the update expression to be an
15088          EXPR_WFL_NODE wrapping nothing.  */
15089       if (up2 != NULL_TREE && up2 != empty_stmt_node)
15090         {
15091           /* Try to detect constraint violations.  These would be
15092              programming errors somewhere.  */
15093           if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
15094               || TREE_CODE (up2) == LOOP_EXPR)
15095             abort ();
15096           SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
15097         }
15098     }
15099   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
15100   return loop;
15101 }
15102
15103 /* Try to find the loop a block might be related to. This comprises
15104    the case where the LOOP_EXPR is found as the second operand of a
15105    COMPOUND_EXPR, because the loop happens to have an initialization
15106    part, then expressed as the first operand of the COMPOUND_EXPR. If
15107    the search finds something, 1 is returned. Otherwise, 0 is
15108    returned. The search is assumed to start from a
15109    LABELED_BLOCK_EXPR's block.  */
15110
15111 static tree
15112 search_loop (tree statement)
15113 {
15114   if (TREE_CODE (statement) == LOOP_EXPR)
15115     return statement;
15116
15117   if (TREE_CODE (statement) == BLOCK)
15118     statement = BLOCK_SUBBLOCKS (statement);
15119   else
15120     return NULL_TREE;
15121
15122   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15123     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15124       statement = TREE_OPERAND (statement, 1);
15125
15126   return (TREE_CODE (statement) == LOOP_EXPR
15127           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
15128 }
15129
15130 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15131    returned otherwise.  */
15132
15133 static int
15134 labeled_block_contains_loop_p (tree block, tree loop)
15135 {
15136   if (!block)
15137     return 0;
15138
15139   if (LABELED_BLOCK_BODY (block) == loop)
15140     return 1;
15141
15142   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
15143     return 1;
15144
15145   return 0;
15146 }
15147
15148 /* If the loop isn't surrounded by a labeled statement, create one and
15149    insert LOOP as its body.  */
15150
15151 static tree
15152 patch_loop_statement (tree loop)
15153 {
15154   tree loop_label;
15155
15156   TREE_TYPE (loop) = void_type_node;
15157   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
15158     return loop;
15159
15160   loop_label = build_labeled_block (0, NULL_TREE);
15161   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15162      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15163   LABELED_BLOCK_BODY (loop_label) = loop;
15164   PUSH_LABELED_BLOCK (loop_label);
15165   return loop_label;
15166 }
15167
15168 /* 14.13, 14.14: break and continue Statements */
15169
15170 /* Build a break or a continue statement. a null NAME indicates an
15171    unlabeled break/continue statement.  */
15172
15173 static tree
15174 build_bc_statement (int location, int is_break, tree name)
15175 {
15176   tree break_continue, label_block_expr = NULL_TREE;
15177
15178   if (name)
15179     {
15180       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15181             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15182         /* Null means that we don't have a target for this named
15183            break/continue. In this case, we make the target to be the
15184            label name, so that the error can be reported accuratly in
15185            patch_bc_statement. */
15186         label_block_expr = EXPR_WFL_NODE (name);
15187     }
15188   /* Unlabeled break/continue will be handled during the
15189      break/continue patch operation */
15190   break_continue
15191     = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
15192
15193   IS_BREAK_STMT_P (break_continue) = is_break;
15194   TREE_SIDE_EFFECTS (break_continue) = 1;
15195   EXPR_WFL_LINECOL (break_continue) = location;
15196   break_continue = build_debugable_stmt (location, break_continue);
15197   return break_continue;
15198 }
15199
15200 /* Verification of a break/continue statement. */
15201
15202 static tree
15203 patch_bc_statement (tree node)
15204 {
15205   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15206   tree labeled_block = ctxp->current_labeled_block;
15207   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15208
15209   /* Having an identifier here means that the target is unknown. */
15210   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15211     {
15212       parse_error_context (wfl_operator, "No label definition found for `%s'",
15213                            IDENTIFIER_POINTER (bc_label));
15214       return error_mark_node;
15215     }
15216   if (! IS_BREAK_STMT_P (node))
15217     {
15218       /* It's a continue statement. */
15219       for (;; labeled_block = TREE_CHAIN (labeled_block))
15220         {
15221           if (labeled_block == NULL_TREE)
15222             {
15223               if (bc_label == NULL_TREE)
15224                 parse_error_context (wfl_operator,
15225                                      "`continue' must be in loop");
15226               else
15227                 parse_error_context
15228                   (wfl_operator, "continue label `%s' does not name a loop",
15229                    IDENTIFIER_POINTER (bc_label));
15230               return error_mark_node;
15231             }
15232           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15233                == continue_identifier_node)
15234               && (bc_label == NULL_TREE
15235                   || TREE_CHAIN (labeled_block) == bc_label))
15236             {
15237               bc_label = labeled_block;
15238               break;
15239             }
15240         }
15241     }
15242   else if (!bc_label)
15243     {
15244       for (;; labeled_block = TREE_CHAIN (labeled_block))
15245         {
15246           if (labeled_block == NULL_TREE)
15247             {
15248               parse_error_context (wfl_operator,
15249                                      "`break' must be in loop or switch");
15250               return error_mark_node;
15251             }
15252           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15253           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15254               || search_loop (target_stmt))
15255             {
15256               bc_label = labeled_block;
15257               break;
15258             }
15259         }
15260     }
15261
15262   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15263   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15264
15265   /* Our break/continue don't return values. */
15266   TREE_TYPE (node) = void_type_node;
15267   /* Encapsulate the break within a compound statement so that it's
15268      expanded all the times by expand_expr (and not clobbered
15269      sometimes, like after a if statement) */
15270   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15271   TREE_SIDE_EFFECTS (node) = 1;
15272   return node;
15273 }
15274
15275 /* Process the exit expression belonging to a loop. Its type must be
15276    boolean.  */
15277
15278 static tree
15279 patch_exit_expr (tree node)
15280 {
15281   tree expression = TREE_OPERAND (node, 0);
15282   TREE_TYPE (node) = error_mark_node;
15283   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15284
15285   /* The type of expression must be boolean */
15286   if (TREE_TYPE (expression) != boolean_type_node)
15287     {
15288       parse_error_context
15289         (wfl_operator,
15290     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15291          lang_printable_name (TREE_TYPE (expression), 0));
15292       return error_mark_node;
15293     }
15294   /* Now we know things are allright, invert the condition, fold and
15295      return */
15296   TREE_OPERAND (node, 0) =
15297     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15298
15299   if (! integer_zerop (TREE_OPERAND (node, 0))
15300       && ctxp->current_loop != NULL_TREE
15301       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15302     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15303   if (! integer_onep (TREE_OPERAND (node, 0)))
15304     CAN_COMPLETE_NORMALLY (node) = 1;
15305
15306
15307   TREE_TYPE (node) = void_type_node;
15308   return node;
15309 }
15310
15311 /* 14.9 Switch statement */
15312
15313 static tree
15314 patch_switch_statement (tree node)
15315 {
15316   tree se = TREE_OPERAND (node, 0), se_type;
15317   tree save, iter;
15318
15319   /* Complete the switch expression */
15320   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15321   se_type = TREE_TYPE (se);
15322   /* The type of the switch expression must be char, byte, short or
15323      int */
15324   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15325     {
15326       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15327       parse_error_context (wfl_operator,
15328           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15329                            lang_printable_name (se_type, 0));
15330       /* This is what java_complete_tree will check */
15331       TREE_OPERAND (node, 0) = error_mark_node;
15332       return error_mark_node;
15333     }
15334
15335   /* Save and restore the outer case label list.  */
15336   save = case_label_list;
15337   case_label_list = NULL_TREE;
15338
15339   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15340
15341   /* See if we've found a duplicate label.  We can't leave this until
15342      code generation, because in `--syntax-only' and `-C' modes we
15343      don't do ordinary code generation.  */
15344   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15345     {
15346       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15347       tree subiter;
15348       for (subiter = TREE_CHAIN (iter);
15349            subiter != NULL_TREE;
15350            subiter = TREE_CHAIN (subiter))
15351         {
15352           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15353           if (val == subval)
15354             {
15355               EXPR_WFL_LINECOL (wfl_operator)
15356                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15357               /* The case_label_list is in reverse order, so print the
15358                  outer label first.  */
15359               parse_error_context (wfl_operator, "duplicate case label: `"
15360                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15361               EXPR_WFL_LINECOL (wfl_operator)
15362                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15363               parse_error_context (wfl_operator, "original label is here");
15364
15365               break;
15366             }
15367         }
15368     }
15369
15370   case_label_list = save;
15371
15372   /* Ready to return */
15373   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15374     {
15375       TREE_TYPE (node) = error_mark_node;
15376       return error_mark_node;
15377     }
15378   TREE_TYPE (node) = void_type_node;
15379   TREE_SIDE_EFFECTS (node) = 1;
15380   CAN_COMPLETE_NORMALLY (node)
15381     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15382       || ! SWITCH_HAS_DEFAULT (node);
15383   return node;
15384 }
15385
15386 /* Assertions.  */
15387
15388 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15389    might be NULL_TREE.  */
15390 static tree
15391 build_assertion (int location, tree condition, tree value)
15392 {
15393   tree node;
15394   tree klass = GET_CPC ();
15395
15396   if (! CLASS_USES_ASSERTIONS (klass))
15397     {
15398       tree field, classdollar, id, call;
15399       tree class_type = TREE_TYPE (klass);
15400
15401       field = add_field (class_type,
15402                          get_identifier ("$assertionsDisabled"),
15403                          boolean_type_node,
15404                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15405       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15406       FIELD_SYNTHETIC (field) = 1;
15407
15408       if (!TYPE_DOT_CLASS (class_type))
15409         build_dot_class_method (class_type);
15410       classdollar = build_dot_class_method_invocation (class_type);
15411
15412       /* Call CLASS.desiredAssertionStatus().  */
15413       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15414       call = build (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15415       call = make_qualified_primary (classdollar, call, location);
15416       TREE_SIDE_EFFECTS (call) = 1;
15417
15418       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15419          seem odd, but we do it to generate code identical to that of
15420          the JDK.  */
15421       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15422       TREE_SIDE_EFFECTS (call) = 1;
15423       DECL_INITIAL (field) = call;
15424
15425       /* Record the initializer in the initializer statement list.  */
15426       call = build (MODIFY_EXPR, NULL_TREE, field, call);
15427       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15428       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15429       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15430
15431       CLASS_USES_ASSERTIONS (klass) = 1;
15432     }
15433
15434   if (value != NULL_TREE)
15435     value = tree_cons (NULL_TREE, value, NULL_TREE);
15436
15437   node = build_wfl_node (get_identifier ("java"));
15438   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15439                               location);
15440   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15441                               location);
15442
15443   node = build (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15444   TREE_SIDE_EFFECTS (node) = 1;
15445   /* It is too early to use BUILD_THROW.  */
15446   node = build1 (THROW_EXPR, NULL_TREE, node);
15447   TREE_SIDE_EFFECTS (node) = 1;
15448
15449   /* We invert the condition; if we just put NODE as the `else' part
15450      then we generate weird-looking bytecode.  */
15451   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15452   /* Check $assertionsDisabled.  */
15453   condition
15454     = build (TRUTH_ANDIF_EXPR, NULL_TREE,
15455              build1 (TRUTH_NOT_EXPR, NULL_TREE,
15456                      build_wfl_node (get_identifier ("$assertionsDisabled"))),
15457              condition);
15458   node = build_if_else_statement (location, condition, node, NULL_TREE);
15459   return node;
15460 }
15461
15462 /* 14.18 The try/catch statements */
15463
15464 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15465    catches TYPE and executes CATCH_STMTS.  */
15466
15467 static tree
15468 encapsulate_with_try_catch (int location, tree type, tree try_stmts,
15469                             tree catch_stmts)
15470 {
15471   tree try_block, catch_clause_param, catch_block, catch;
15472
15473   /* First build a try block */
15474   try_block = build_expr_block (try_stmts, NULL_TREE);
15475
15476   /* Build a catch block: we need a catch clause parameter */
15477   catch_clause_param = build_decl (VAR_DECL,
15478                                    wpv_id, build_pointer_type (type));
15479   /* And a block */
15480   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15481
15482   /* Initialize the variable and store in the block */
15483   catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15484                  build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15485   add_stmt_to_block (catch_block, NULL_TREE, catch);
15486
15487   /* Add the catch statements */
15488   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15489
15490   /* Now we can build a CATCH_EXPR */
15491   catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
15492
15493   return build_try_statement (location, try_block, catch_block);
15494 }
15495
15496 static tree
15497 build_try_statement (int location, tree try_block, tree catches)
15498 {
15499   tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
15500   EXPR_WFL_LINECOL (node) = location;
15501   return node;
15502 }
15503
15504 static tree
15505 build_try_finally_statement (int location, tree try_block, tree finally)
15506 {
15507   tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15508   EXPR_WFL_LINECOL (node) = location;
15509   return node;
15510 }
15511
15512 static tree
15513 patch_try_statement (tree node)
15514 {
15515   int error_found = 0;
15516   tree try = TREE_OPERAND (node, 0);
15517   /* Exception handlers are considered in left to right order */
15518   tree catch = nreverse (TREE_OPERAND (node, 1));
15519   tree current, caught_type_list = NULL_TREE;
15520
15521   /* Check catch clauses, if any. Every time we find an error, we try
15522      to process the next catch clause. We process the catch clause before
15523      the try block so that when processing the try block we can check thrown
15524      exceptions againts the caught type list. */
15525   for (current = catch; current; current = TREE_CHAIN (current))
15526     {
15527       tree carg_decl, carg_type;
15528       tree sub_current, catch_block, catch_clause;
15529       int unreachable;
15530
15531       /* At this point, the structure of the catch clause is
15532            CATCH_EXPR           (catch node)
15533              BLOCK              (with the decl of the parameter)
15534                COMPOUND_EXPR
15535                  MODIFY_EXPR   (assignment of the catch parameter)
15536                  BLOCK          (catch clause block)
15537        */
15538       catch_clause = TREE_OPERAND (current, 0);
15539       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15540       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15541
15542       /* Catch clauses can't have more than one parameter declared,
15543          but it's already enforced by the grammar. Make sure that the
15544          only parameter of the clause statement in of class Throwable
15545          or a subclass of Throwable, but that was done earlier. The
15546          catch clause parameter type has also been resolved. */
15547
15548       /* Just make sure that the catch clause parameter type inherits
15549          from java.lang.Throwable */
15550       if (!inherits_from_p (carg_type, throwable_type_node))
15551         {
15552           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15553           parse_error_context (wfl_operator,
15554                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15555                                lang_printable_name (carg_type, 0));
15556           error_found = 1;
15557           continue;
15558         }
15559
15560       /* Partial check for unreachable catch statement: The catch
15561          clause is reachable iff is no earlier catch block A in
15562          the try statement such that the type of the catch
15563          clause's parameter is the same as or a subclass of the
15564          type of A's parameter */
15565       unreachable = 0;
15566       for (sub_current = catch;
15567            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15568         {
15569           tree sub_catch_clause, decl;
15570           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15571           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15572
15573           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15574             {
15575               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15576               parse_error_context
15577                 (wfl_operator,
15578                  "`catch' not reached because of the catch clause at line %d",
15579                  EXPR_WFL_LINENO (sub_current));
15580               unreachable = error_found = 1;
15581               break;
15582             }
15583         }
15584       /* Complete the catch clause block */
15585       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15586       if (catch_block == error_mark_node)
15587         {
15588           error_found = 1;
15589           continue;
15590         }
15591       if (CAN_COMPLETE_NORMALLY (catch_block))
15592         CAN_COMPLETE_NORMALLY (node) = 1;
15593       TREE_OPERAND (current, 0) = catch_block;
15594
15595       if (unreachable)
15596         continue;
15597
15598       /* Things to do here: the exception must be thrown */
15599
15600       /* Link this type to the caught type list */
15601       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15602     }
15603
15604   PUSH_EXCEPTIONS (caught_type_list);
15605   if ((try = java_complete_tree (try)) == error_mark_node)
15606     error_found = 1;
15607   if (CAN_COMPLETE_NORMALLY (try))
15608     CAN_COMPLETE_NORMALLY (node) = 1;
15609   POP_EXCEPTIONS ();
15610
15611   /* Verification ends here */
15612   if (error_found)
15613     return error_mark_node;
15614
15615   TREE_OPERAND (node, 0) = try;
15616   TREE_OPERAND (node, 1) = catch;
15617   TREE_TYPE (node) = void_type_node;
15618   return node;
15619 }
15620
15621 /* 14.17 The synchronized Statement */
15622
15623 static tree
15624 patch_synchronized_statement (tree node, tree wfl_op1)
15625 {
15626   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15627   tree block = TREE_OPERAND (node, 1);
15628
15629   tree tmp, enter, exit, expr_decl, assignment;
15630
15631   if (expr == error_mark_node)
15632     {
15633       block = java_complete_tree (block);
15634       return expr;
15635     }
15636
15637   /* We might be trying to synchronize on a STRING_CST */
15638   if ((tmp = patch_string (expr)))
15639     expr = tmp;
15640
15641   /* The TYPE of expr must be a reference type */
15642   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15643     {
15644       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15645       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15646                            lang_printable_name (TREE_TYPE (expr), 0));
15647       return error_mark_node;
15648     }
15649
15650   if (flag_emit_xref)
15651     {
15652       TREE_OPERAND (node, 0) = expr;
15653       TREE_OPERAND (node, 1) = java_complete_tree (block);
15654       CAN_COMPLETE_NORMALLY (node) = 1;
15655       return node;
15656     }
15657
15658   /* Generate a try-finally for the synchronized statement, except
15659      that the handler that catches all throw exception calls
15660      _Jv_MonitorExit and then rethrow the exception.
15661      The synchronized statement is then implemented as:
15662      TRY
15663        {
15664          _Jv_MonitorEnter (expression)
15665          synchronized_block
15666          _Jv_MonitorExit (expression)
15667        }
15668      CATCH_ALL
15669        {
15670          e = _Jv_exception_info ();
15671          _Jv_MonitorExit (expression)
15672          Throw (e);
15673        } */
15674
15675   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15676   BUILD_MONITOR_ENTER (enter, expr_decl);
15677   BUILD_MONITOR_EXIT (exit, expr_decl);
15678   CAN_COMPLETE_NORMALLY (enter) = 1;
15679   CAN_COMPLETE_NORMALLY (exit) = 1;
15680   assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15681   TREE_SIDE_EFFECTS (assignment) = 1;
15682   node = build (COMPOUND_EXPR, NULL_TREE,
15683                 build (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15684                 build (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15685   node = build_expr_block (node, expr_decl);
15686
15687   return java_complete_tree (node);
15688 }
15689
15690 /* 14.16 The throw Statement */
15691
15692 static tree
15693 patch_throw_statement (tree node, tree wfl_op1)
15694 {
15695   tree expr = TREE_OPERAND (node, 0);
15696   tree type = TREE_TYPE (expr);
15697   int unchecked_ok = 0, tryblock_throws_ok = 0;
15698
15699   /* Thrown expression must be assignable to java.lang.Throwable */
15700   if (!try_reference_assignconv (throwable_type_node, expr))
15701     {
15702       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15703       parse_error_context (wfl_operator,
15704     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15705                            lang_printable_name (type, 0));
15706       /* If the thrown expression was a reference, we further the
15707          compile-time check. */
15708       if (!JREFERENCE_TYPE_P (type))
15709         return error_mark_node;
15710     }
15711
15712   /* At least one of the following must be true */
15713
15714   /* The type of the throw expression is a not checked exception,
15715      i.e. is a unchecked expression. */
15716   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15717
15718   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15719   /* An instance can't throw a checked exception unless that exception
15720      is explicitly declared in the `throws' clause of each
15721      constructor. This doesn't apply to anonymous classes, since they
15722      don't have declared constructors. */
15723   if (!unchecked_ok
15724       && DECL_INSTINIT_P (current_function_decl)
15725       && !ANONYMOUS_CLASS_P (current_class))
15726     {
15727       tree current;
15728       for (current = TYPE_METHODS (current_class); current;
15729            current = TREE_CHAIN (current))
15730         if (DECL_CONSTRUCTOR_P (current)
15731             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15732           {
15733             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)",
15734                                  lang_printable_name (TREE_TYPE (expr), 0));
15735             return error_mark_node;
15736           }
15737     }
15738
15739   /* Throw is contained in a try statement and at least one catch
15740      clause can receive the thrown expression or the current method is
15741      declared to throw such an exception. Or, the throw statement is
15742      contained in a method or constructor declaration and the type of
15743      the Expression is assignable to at least one type listed in the
15744      throws clause the declaration. */
15745   if (!unchecked_ok)
15746     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15747   if (!(unchecked_ok || tryblock_throws_ok))
15748     {
15749       /* If there is a surrounding try block that has no matching
15750          clatch clause, report it first. A surrounding try block exits
15751          only if there is something after the list of checked
15752          exception thrown by the current function (if any). */
15753       if (IN_TRY_BLOCK_P ())
15754         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15755                              lang_printable_name (type, 0));
15756       /* If we have no surrounding try statement and the method doesn't have
15757          any throws, report it now. FIXME */
15758
15759       /* We report that the exception can't be throw from a try block
15760          in all circumstances but when the `throw' is inside a static
15761          block. */
15762       else if (!EXCEPTIONS_P (currently_caught_type_list)
15763                && !tryblock_throws_ok)
15764         {
15765           if (DECL_CLINIT_P (current_function_decl))
15766             parse_error_context (wfl_operator,
15767                    "Checked exception `%s' can't be thrown in initializer",
15768                                  lang_printable_name (type, 0));
15769           else
15770             parse_error_context (wfl_operator,
15771                    "Checked exception `%s' isn't thrown from a `try' block",
15772                                  lang_printable_name (type, 0));
15773         }
15774       /* Otherwise, the current method doesn't have the appropriate
15775          throws declaration */
15776       else
15777         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15778                              lang_printable_name (type, 0));
15779       return error_mark_node;
15780     }
15781
15782   if (! flag_emit_class_files && ! flag_emit_xref)
15783     BUILD_THROW (node, expr);
15784
15785   /* If doing xrefs, keep the location where the `throw' was seen. */
15786   if (flag_emit_xref)
15787     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15788   return node;
15789 }
15790
15791 /* Check that exception said to be thrown by method DECL can be
15792    effectively caught from where DECL is invoked.  THIS_EXPR is the
15793    expression that computes `this' for the method call.  */
15794 static void
15795 check_thrown_exceptions (int location, tree decl, tree this_expr)
15796 {
15797   tree throws;
15798   int is_array_call = 0;
15799
15800   if (this_expr != NULL_TREE
15801       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15802       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15803     is_array_call = 1;
15804
15805   /* For all the unchecked exceptions thrown by DECL.  */
15806   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15807        throws = TREE_CHAIN (throws))
15808     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15809       {
15810         /* Suppress errors about cloning arrays.  */
15811         if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15812           continue;
15813
15814         EXPR_WFL_LINECOL (wfl_operator) = location;
15815         if (DECL_FINIT_P (current_function_decl))
15816           parse_error_context
15817             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15818              lang_printable_name (TREE_VALUE (throws), 0));
15819         else
15820           {
15821             parse_error_context
15822               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15823                lang_printable_name (TREE_VALUE (throws), 0),
15824                (DECL_INIT_P (current_function_decl) ?
15825                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15826                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15827           }
15828       }
15829 }
15830
15831 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15832    try-catch blocks, OR is listed in the `throws' clause of the
15833    current method.  */
15834
15835 static int
15836 check_thrown_exceptions_do (tree exception)
15837 {
15838   tree list = currently_caught_type_list;
15839   resolve_and_layout (exception, NULL_TREE);
15840   /* First, all the nested try-catch-finally at that stage. The
15841      last element contains `throws' clause exceptions, if any. */
15842   if (IS_UNCHECKED_EXCEPTION_P (exception))
15843     return 1;
15844   while (list)
15845     {
15846       tree caught;
15847       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15848         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15849           return 1;
15850       list = TREE_CHAIN (list);
15851     }
15852   return 0;
15853 }
15854
15855 static void
15856 purge_unchecked_exceptions (tree mdecl)
15857 {
15858   tree throws = DECL_FUNCTION_THROWS (mdecl);
15859   tree new = NULL_TREE;
15860
15861   while (throws)
15862     {
15863       tree next = TREE_CHAIN (throws);
15864       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15865         {
15866           TREE_CHAIN (throws) = new;
15867           new = throws;
15868         }
15869       throws = next;
15870     }
15871   /* List is inverted here, but it doesn't matter */
15872   DECL_FUNCTION_THROWS (mdecl) = new;
15873 }
15874
15875 /* This function goes over all of CLASS_TYPE ctors and checks whether
15876    each of them features at least one unchecked exception in its
15877    `throws' clause. If it's the case, it returns `true', `false'
15878    otherwise.  */
15879
15880 static bool
15881 ctors_unchecked_throws_clause_p (tree class_type)
15882 {
15883   tree current;
15884
15885   for (current = TYPE_METHODS (class_type); current;
15886        current = TREE_CHAIN (current))
15887     {
15888       bool ctu = false; /* Ctor Throws Unchecked */
15889       if (DECL_CONSTRUCTOR_P (current))
15890         {
15891           tree throws;
15892           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15893                throws = TREE_CHAIN (throws))
15894             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15895               ctu = true;
15896         }
15897       /* We return false as we found one ctor that is unfit. */
15898       if (!ctu && DECL_CONSTRUCTOR_P (current))
15899         return false;
15900     }
15901   /* All ctors feature at least one unchecked exception in their
15902      `throws' clause. */
15903   return true;
15904 }
15905
15906 /* 15.24 Conditional Operator ?: */
15907
15908 static tree
15909 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15910 {
15911   tree cond = TREE_OPERAND (node, 0);
15912   tree op1 = TREE_OPERAND (node, 1);
15913   tree op2 = TREE_OPERAND (node, 2);
15914   tree resulting_type = NULL_TREE;
15915   tree t1, t2, patched;
15916   int error_found = 0;
15917
15918   /* Operands of ?: might be StringBuffers crafted as a result of a
15919      string concatenation. Obtain a descent operand here.  */
15920   if ((patched = patch_string (op1)))
15921     TREE_OPERAND (node, 1) = op1 = patched;
15922   if ((patched = patch_string (op2)))
15923     TREE_OPERAND (node, 2) = op2 = patched;
15924
15925   t1 = TREE_TYPE (op1);
15926   t2 = TREE_TYPE (op2);
15927
15928   /* The first expression must be a boolean */
15929   if (TREE_TYPE (cond) != boolean_type_node)
15930     {
15931       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15932       parse_error_context (wfl_operator,
15933                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15934                            lang_printable_name (TREE_TYPE (cond), 0));
15935       error_found = 1;
15936     }
15937
15938   /* Second and third can be numeric, boolean (i.e. primitive),
15939      references or null. Anything else results in an error */
15940   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15941         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15942             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15943         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15944     error_found = 1;
15945
15946   /* Determine the type of the conditional expression. Same types are
15947      easy to deal with */
15948   else if (t1 == t2)
15949     resulting_type = t1;
15950
15951   /* There are different rules for numeric types */
15952   else if (JNUMERIC_TYPE_P (t1))
15953     {
15954       /* if byte/short found, the resulting type is short */
15955       if ((t1 == byte_type_node && t2 == short_type_node)
15956           || (t1 == short_type_node && t2 == byte_type_node))
15957         resulting_type = short_type_node;
15958
15959       /* If t1 is a constant int and t2 is of type byte, short or char
15960          and t1's value fits in t2, then the resulting type is t2 */
15961       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15962           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15963         resulting_type = t2;
15964
15965       /* If t2 is a constant int and t1 is of type byte, short or char
15966          and t2's value fits in t1, then the resulting type is t1 */
15967       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15968           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15969         resulting_type = t1;
15970
15971       /* Otherwise, binary numeric promotion is applied and the
15972          resulting type is the promoted type of operand 1 and 2 */
15973       else
15974         resulting_type = binary_numeric_promotion (t1, t2,
15975                                                    &TREE_OPERAND (node, 1),
15976                                                    &TREE_OPERAND (node, 2));
15977     }
15978
15979   /* Cases of a reference and a null type */
15980   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15981     resulting_type = t1;
15982
15983   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15984     resulting_type = t2;
15985
15986   /* Last case: different reference types. If a type can be converted
15987      into the other one by assignment conversion, the latter
15988      determines the type of the expression */
15989   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15990     resulting_type = promote_type (t1);
15991
15992   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15993     resulting_type = promote_type (t2);
15994
15995   /* If we don't have any resulting type, we're in trouble */
15996   if (!resulting_type)
15997     {
15998       char *t = xstrdup (lang_printable_name (t1, 0));
15999       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
16000       parse_error_context (wfl_operator,
16001                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
16002                            t, lang_printable_name (t2, 0));
16003       free (t);
16004       error_found = 1;
16005     }
16006
16007   if (error_found)
16008     {
16009       TREE_TYPE (node) = error_mark_node;
16010       return error_mark_node;
16011     }
16012
16013   TREE_TYPE (node) = resulting_type;
16014   TREE_SET_CODE (node, COND_EXPR);
16015   CAN_COMPLETE_NORMALLY (node) = 1;
16016   return node;
16017 }
16018
16019 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
16020
16021 static tree
16022 maybe_build_class_init_for_field (tree decl, tree expr)
16023 {
16024   tree clas = DECL_CONTEXT (decl);
16025   if (flag_emit_class_files || flag_emit_xref)
16026     return expr;
16027
16028   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
16029       && FIELD_FINAL (decl))
16030     {
16031       tree init = DECL_INITIAL (decl);
16032       if (init != NULL_TREE)
16033         init = fold_constant_for_init (init, decl);
16034       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
16035         return expr;
16036     }
16037
16038   return build_class_init (clas, expr);
16039 }
16040
16041 /* Try to constant fold NODE.
16042    If NODE is not a constant expression, return NULL_EXPR.
16043    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
16044
16045 static tree
16046 fold_constant_for_init (tree node, tree context)
16047 {
16048   tree op0, op1, val;
16049   enum tree_code code = TREE_CODE (node);
16050
16051   switch (code)
16052     {
16053     case INTEGER_CST:
16054       if (node == null_pointer_node)
16055         return NULL_TREE;
16056     case STRING_CST:
16057     case REAL_CST:
16058       return node;
16059
16060     case PLUS_EXPR:
16061     case MINUS_EXPR:
16062     case MULT_EXPR:
16063     case TRUNC_MOD_EXPR:
16064     case RDIV_EXPR:
16065     case LSHIFT_EXPR:
16066     case RSHIFT_EXPR:
16067     case URSHIFT_EXPR:
16068     case BIT_AND_EXPR:
16069     case BIT_XOR_EXPR:
16070     case BIT_IOR_EXPR:
16071     case TRUTH_ANDIF_EXPR:
16072     case TRUTH_ORIF_EXPR:
16073     case EQ_EXPR:
16074     case NE_EXPR:
16075     case GT_EXPR:
16076     case GE_EXPR:
16077     case LT_EXPR:
16078     case LE_EXPR:
16079       op0 = TREE_OPERAND (node, 0);
16080       op1 = TREE_OPERAND (node, 1);
16081       val = fold_constant_for_init (op0, context);
16082       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16083         return NULL_TREE;
16084       TREE_OPERAND (node, 0) = val;
16085       val = fold_constant_for_init (op1, context);
16086       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16087         return NULL_TREE;
16088       TREE_OPERAND (node, 1) = val;
16089       return patch_binop (node, op0, op1);
16090
16091     case UNARY_PLUS_EXPR:
16092     case NEGATE_EXPR:
16093     case TRUTH_NOT_EXPR:
16094     case BIT_NOT_EXPR:
16095     case CONVERT_EXPR:
16096       op0 = TREE_OPERAND (node, 0);
16097       val = fold_constant_for_init (op0, context);
16098       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16099         return NULL_TREE;
16100       TREE_OPERAND (node, 0) = val;
16101       return patch_unaryop (node, op0);
16102       break;
16103
16104     case COND_EXPR:
16105       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
16106       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16107         return NULL_TREE;
16108       TREE_OPERAND (node, 0) = val;
16109       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
16110       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16111         return NULL_TREE;
16112       TREE_OPERAND (node, 1) = val;
16113       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
16114       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16115         return NULL_TREE;
16116       TREE_OPERAND (node, 2) = val;
16117       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
16118         : TREE_OPERAND (node, 2);
16119
16120     case VAR_DECL:
16121     case FIELD_DECL:
16122       if (! FIELD_FINAL (node)
16123           || DECL_INITIAL (node) == NULL_TREE)
16124         return NULL_TREE;
16125       val = DECL_INITIAL (node);
16126       /* Guard against infinite recursion. */
16127       DECL_INITIAL (node) = NULL_TREE;
16128       val = fold_constant_for_init (val, node);
16129       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
16130         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
16131       DECL_INITIAL (node) = val;
16132       return val;
16133
16134     case EXPR_WITH_FILE_LOCATION:
16135       /* Compare java_complete_tree and resolve_expression_name. */
16136       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
16137           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
16138         {
16139           tree name = EXPR_WFL_NODE (node);
16140           tree decl;
16141           if (PRIMARY_P (node))
16142             return NULL_TREE;
16143           else if (! QUALIFIED_P (name))
16144             {
16145               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
16146               if (decl == NULL_TREE
16147                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16148                 return NULL_TREE;
16149               return fold_constant_for_init (decl, decl);
16150             }
16151           else
16152             {
16153               /* Install the proper context for the field resolution.
16154                  The prior context is restored once the name is
16155                  properly qualified. */
16156               tree saved_current_class = current_class;
16157               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
16158               current_class = DECL_CONTEXT (context);
16159               qualify_ambiguous_name (node);
16160               current_class = saved_current_class;
16161               if (resolve_field_access (node, &decl, NULL)
16162                   && decl != NULL_TREE)
16163                 return fold_constant_for_init (decl, decl);
16164               return NULL_TREE;
16165             }
16166         }
16167       else
16168         {
16169           op0 = TREE_OPERAND (node, 0);
16170           val = fold_constant_for_init (op0, context);
16171           if (val == NULL_TREE || ! TREE_CONSTANT (val))
16172             return NULL_TREE;
16173           TREE_OPERAND (node, 0) = val;
16174           return val;
16175         }
16176
16177 #ifdef USE_COMPONENT_REF
16178     case IDENTIFIER:
16179     case COMPONENT_REF:
16180       ?;
16181 #endif
16182
16183     default:
16184       return NULL_TREE;
16185     }
16186 }
16187
16188 #ifdef USE_COMPONENT_REF
16189 /* Context is 'T' for TypeName, 'P' for PackageName,
16190    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16191
16192 tree
16193 resolve_simple_name (tree name, int context)
16194 {
16195 }
16196
16197 tree
16198 resolve_qualified_name (tree name, int context)
16199 {
16200 }
16201 #endif
16202
16203 void
16204 init_src_parse (void)
16205 {
16206   /* Sanity check; we've been bit by this before.  */
16207   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16208     abort ();
16209 }
16210
16211 \f
16212
16213 /* This section deals with the functions that are called when tables
16214    recording class initialization information are traversed.  */
16215
16216 /* Attach to PTR (a block) the declaration found in ENTRY. */
16217
16218 static int
16219 attach_init_test_initialization_flags (void **entry, void *ptr)
16220 {
16221   tree block = (tree)ptr;
16222   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16223
16224   if (block != error_mark_node)
16225     {
16226       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16227       BLOCK_EXPR_DECLS (block) = ite->value;
16228     }
16229   return true;
16230 }
16231
16232 /* This function is called for each classes that is known definitely
16233    assigned when a given static method was called. This function
16234    augments a compound expression (INFO) storing all assignment to
16235    initialized static class flags if a flag already existed, otherwise
16236    a new one is created.  */
16237
16238 static int
16239 emit_test_initialization (void **entry_p, void *info)
16240 {
16241   tree l = (tree) info;
16242   tree decl, init;
16243   tree key = (tree) *entry_p;
16244   tree *ite;
16245   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16246
16247   /* If we haven't found a flag and we're dealing with self registered
16248      with current_function_decl, then don't do anything. Self is
16249      always added as definitely initialized but this information is
16250      valid only if used outside the current function. */
16251   if (current_function_decl == TREE_PURPOSE (l)
16252       && java_treetreehash_find (cf_ht, key) == NULL)
16253     return true;
16254
16255   ite = java_treetreehash_new (cf_ht, key);
16256
16257   /* If we don't have a variable, create one and install it. */
16258   if (*ite == NULL)
16259     {
16260       tree block;
16261
16262       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16263       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16264       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16265       DECL_CONTEXT (decl) = current_function_decl;
16266       DECL_INITIAL (decl) = boolean_true_node;
16267       /* Don't emit any symbolic debugging info for this decl.  */
16268       DECL_IGNORED_P (decl) = 1;
16269
16270       /* The trick is to find the right context for it. */
16271       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16272       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16273       BLOCK_EXPR_DECLS (block) = decl;
16274       *ite = decl;
16275     }
16276   else
16277     decl = *ite;
16278
16279   /* Now simply augment the compound that holds all the assignments
16280      pertaining to this method invocation. */
16281   init = build (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16282   TREE_SIDE_EFFECTS (init) = 1;
16283   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16284   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16285
16286   return true;
16287 }
16288
16289 #include "gt-java-parse.h"
16290 #include "gtype-java.h"