gcc/java/parse.y

   1 /* Source code parsing and tree node generation for the GNU compiler
   2    for the Java(TM) language.
   3    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
   4    Free Software Foundation, Inc.
   5    Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.
  23
  24 Java and all Java-based marks are trademarks or registered trademarks
  25 of Sun Microsystems, Inc. in the United States and other countries.
  26 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  27
  28 /* This file parses java source code and issues a tree node image
  29 suitable for code generation (byte code and targeted CPU assembly
  30 language).
  31
  32 The grammar conforms to the Java grammar described in "The Java(TM)
  33 Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
  34 1996, ISBN 0-201-63451-1"
  35
  36 The following modifications were brought to the original grammar:
  37
  38 method_body: added the rule '| block SC_TK'
  39 static_initializer: added the rule 'static block SC_TK'.
  40
  41 Note: All the extra rules described above should go away when the
  42       empty_statement rule will work.
  43
  44 statement_nsi: 'nsi' should be read no_short_if.
  45
  46 Some rules have been modified to support JDK1.1 inner classes
  47 definitions and other extensions.  */
  48
  49 %{
  50 #include "config.h"
  51 #include "system.h"
  52 #include "coretypes.h"
  53 #include "tm.h"
  54 #include <dirent.h>
  55 #include "tree.h"
  56 #include "rtl.h"
  57 #include "real.h"
  58 #include "obstack.h"
  59 #include "toplev.h"
  60 #include "flags.h"
  61 #include "java-tree.h"
  62 #include "jcf.h"
  63 #include "lex.h"
  64 #include "parse.h"
  65 #include "zipfile.h"
  66 #include "convert.h"
  67 #include "buffer.h"
  68 #include "xref.h"
  69 #include "function.h"
  70 #include "except.h"
  71 #include "ggc.h"
  72 #include "debug.h"
  73 #include "tree-inline.h"
  74 #include "cgraph.h"
  75 #include "target.h"
  76
  77 /* Local function prototypes */
  78 static char *java_accstring_lookup (int);
  79 static const char *accessibility_string (int);
  80 static void  classitf_redefinition_error (const char *,tree, tree, tree);
  81 static void  variable_redefinition_error (tree, tree, tree, int);
  82 static tree  create_class (int, tree, tree, tree);
  83 static tree  create_interface (int, tree, tree);
  84 static void  end_class_declaration (int);
  85 static tree  find_field (tree, tree);
  86 static tree lookup_field_wrapper (tree, tree);
  87 static int   duplicate_declaration_error_p (tree, tree, tree);
  88 static void  register_fields (int, tree, tree);
  89 static tree parser_qualified_classname (tree);
  90 static int  parser_check_super (tree, tree, tree);
  91 static int  parser_check_super_interface (tree, tree, tree);
  92 static void check_modifiers_consistency (int);
  93 static tree lookup_cl (tree);
  94 static tree lookup_java_method2 (tree, tree, int);
  95 static tree method_header (int, tree, tree, tree);
  96 static void fix_method_argument_names (tree ,tree);
  97 static tree method_declarator (tree, tree);
  98 static void parse_warning_context (tree cl, const char *msg, ...)
  99   ATTRIBUTE_PRINTF_2;
 100 static void issue_warning_error_from_context (tree, const char *msg, va_list)
 101   ATTRIBUTE_PRINTF (2, 0);
 102 static void parse_ctor_invocation_error (void);
 103 static tree parse_jdk1_1_error (const char *);
 104 static void complete_class_report_errors (jdep *);
 105 static int process_imports (void);
 106 static void read_import_dir (tree);
 107 static int find_in_imports_on_demand (tree, tree);
 108 static void find_in_imports (tree, tree);
 109 static void check_inner_class_access (tree, tree, tree);
 110 static int check_pkg_class_access (tree, tree, bool, tree);
 111 static void register_package (tree);
 112 static tree resolve_package (tree, tree *, tree *);
 113 static tree resolve_class (tree, tree, tree, tree);
 114 static void declare_local_variables (int, tree, tree);
 115 static void dump_java_tree (enum tree_dump_index, tree);
 116 static void source_start_java_method (tree);
 117 static void source_end_java_method (void);
 118 static tree find_name_in_single_imports (tree);
 119 static void check_abstract_method_header (tree);
 120 static tree lookup_java_interface_method2 (tree, tree);
 121 static tree resolve_expression_name (tree, tree *);
 122 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
 123 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
 124 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
 125 static tree resolve_and_layout (tree, tree);
 126 static tree qualify_and_find (tree, tree, tree);
 127 static tree resolve_no_layout (tree, tree);
 128 static int invocation_mode (tree, int);
 129 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
 130 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
 131 static tree find_most_specific_methods_list (tree);
 132 static int argument_types_convertible (tree, tree);
 133 static tree patch_invoke (tree, tree, tree);
 134 static int maybe_use_access_method (int, tree *, tree *);
 135 static tree lookup_method_invoke (int, tree, tree, tree, tree);
 136 static tree register_incomplete_type (int, tree, tree, tree);
 137 static tree check_inner_circular_reference (tree, tree);
 138 static tree check_circular_reference (tree);
 139 static tree obtain_incomplete_type (tree);
 140 static tree java_complete_lhs (tree);
 141 static tree java_complete_tree (tree);
 142 static tree maybe_generate_pre_expand_clinit (tree);
 143 static int analyze_clinit_body (tree, tree);
 144 static int maybe_yank_clinit (tree);
 145 static void start_complete_expand_method (tree);
 146 static void java_complete_expand_method (tree);
 147 static void java_expand_method_bodies (tree);
 148 static int  unresolved_type_p (tree, tree *);
 149 static void create_jdep_list (struct parser_ctxt *);
 150 static tree build_expr_block (tree, tree);
 151 static tree enter_block (void);
 152 static tree exit_block (void);
 153 static tree lookup_name_in_blocks (tree);
 154 static void maybe_absorb_scoping_blocks (void);
 155 static tree build_method_invocation (tree, tree);
 156 static tree build_new_invocation (tree, tree);
 157 static tree build_assignment (int, int, tree, tree);
 158 static tree build_binop (enum tree_code, int, tree, tree);
 159 static tree patch_assignment (tree, tree);
 160 static tree patch_binop (tree, tree, tree);
 161 static tree build_unaryop (int, int, tree);
 162 static tree build_incdec (int, int, tree, int);
 163 static tree patch_unaryop (tree, tree);
 164 static tree build_cast (int, tree, tree);
 165 static tree build_null_of_type (tree);
 166 static tree patch_cast (tree, tree);
 167 static int valid_ref_assignconv_cast_p (tree, tree, int);
 168 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
 169 static int valid_cast_to_p (tree, tree);
 170 static int valid_method_invocation_conversion_p (tree, tree);
 171 static tree try_builtin_assignconv (tree, tree, tree);
 172 static tree try_reference_assignconv (tree, tree);
 173 static tree build_unresolved_array_type (tree);
 174 static int build_type_name_from_array_name (tree, tree *);
 175 static tree build_array_from_name (tree, tree, tree, tree *);
 176 static tree build_array_ref (int, tree, tree);
 177 static tree patch_array_ref (tree);
 178 static tree make_qualified_name (tree, tree, int);
 179 static tree merge_qualified_name (tree, tree);
 180 static tree make_qualified_primary (tree, tree, int);
 181 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
 182 static void qualify_ambiguous_name (tree);
 183 static tree resolve_field_access (tree, tree *, tree *);
 184 static tree build_newarray_node (tree, tree, int);
 185 static tree patch_newarray (tree);
 186 static tree resolve_type_during_patch (tree);
 187 static tree build_this (int);
 188 static tree build_wfl_wrap (tree, int);
 189 static tree build_return (int, tree);
 190 static tree patch_return (tree);
 191 static tree maybe_access_field (tree, tree, tree);
 192 static int complete_function_arguments (tree);
 193 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
 194 static int not_accessible_p (tree, tree, tree, int);
 195 static void check_deprecation (tree, tree);
 196 static int class_in_current_package (tree);
 197 static tree build_if_else_statement (int, tree, tree, tree);
 198 static tree patch_if_else_statement (tree);
 199 static tree add_stmt_to_block (tree, tree, tree);
 200 static tree patch_exit_expr (tree);
 201 static tree build_labeled_block (int, tree);
 202 static tree finish_labeled_statement (tree, tree);
 203 static tree build_bc_statement (int, int, tree);
 204 static tree patch_bc_statement (tree);
 205 static tree patch_loop_statement (tree);
 206 static tree build_new_loop (tree);
 207 static tree build_loop_body (int, tree, int);
 208 static tree finish_loop_body (int, tree, tree, int);
 209 static tree build_debugable_stmt (int, tree);
 210 static tree finish_for_loop (int, tree, tree, tree);
 211 static tree patch_switch_statement (tree);
 212 static tree string_constant_concatenation (tree, tree);
 213 static tree build_string_concatenation (tree, tree);
 214 static tree patch_string_cst (tree);
 215 static tree patch_string (tree);
 216 static tree encapsulate_with_try_catch (int, tree, tree, tree);
 217 static tree build_assertion (int, tree, tree);
 218 static tree build_try_statement (int, tree, tree);
 219 static tree build_try_finally_statement (int, tree, tree);
 220 static tree patch_try_statement (tree);
 221 static tree patch_synchronized_statement (tree, tree);
 222 static tree patch_throw_statement (tree, tree);
 223 static void check_thrown_exceptions (int, tree, tree);
 224 static int check_thrown_exceptions_do (tree);
 225 static void purge_unchecked_exceptions (tree);
 226 static bool ctors_unchecked_throws_clause_p (tree);
 227 static void check_concrete_throws_clauses (tree, tree, tree, tree);
 228 static void check_throws_clauses (tree, tree, tree);
 229 static void finish_method_declaration (tree);
 230 static tree build_super_invocation (tree);
 231 static int verify_constructor_circularity (tree, tree);
 232 static char *constructor_circularity_msg (tree, tree);
 233 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
 234 static const char *get_printable_method_name (tree);
 235 static tree patch_conditional_expr (tree, tree, tree);
 236 static tree generate_finit (tree);
 237 static tree generate_instinit (tree);
 238 static tree build_instinit_invocation (tree);
 239 static void fix_constructors (tree);
 240 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
 241 static tree craft_constructor (tree, tree);
 242 static int verify_constructor_super (tree);
 243 static tree create_artificial_method (tree, int, tree, tree, tree);
 244 static void start_artificial_method_body (tree);
 245 static void end_artificial_method_body (tree);
 246 static int check_method_redefinition (tree, tree);
 247 static int check_method_types_complete (tree);
 248 static bool hack_is_accessible_p (tree, tree);
 249 static void java_check_regular_methods (tree);
 250 static void check_interface_throws_clauses (tree, tree);
 251 static void java_check_abstract_methods (tree);
 252 static void unreachable_stmt_error (tree);
 253 static int not_accessible_field_error (tree, tree);
 254 static tree find_expr_with_wfl (tree);
 255 static void missing_return_error (tree);
 256 static tree build_new_array_init (int, tree);
 257 static tree patch_new_array_init (tree, tree);
 258 static tree maybe_build_array_element_wfl (tree);
 259 static int array_constructor_check_entry (tree, tree);
 260 static const char *purify_type_name (const char *);
 261 static tree fold_constant_for_init (tree, tree);
 262 static tree strip_out_static_field_access_decl (tree);
 263 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
 264 static void static_ref_err (tree, tree, tree);
 265 static void parser_add_interface (tree, tree, tree);
 266 static void add_superinterfaces (tree, tree);
 267 static tree jdep_resolve_class (jdep *);
 268 static int note_possible_classname (const char *, int);
 269 static void java_complete_expand_classes (void);
 270 static void java_complete_expand_class (tree);
 271 static void java_complete_expand_methods (tree);
 272 static tree cut_identifier_in_qualified (tree);
 273 static tree java_stabilize_reference (tree);
 274 static tree do_unary_numeric_promotion (tree);
 275 static char * operator_string (tree);
 276 static tree do_merge_string_cste (tree, const char *, int, int);
 277 static tree merge_string_cste (tree, tree, int);
 278 static tree java_refold (tree);
 279 static int java_decl_equiv (tree, tree);
 280 static int binop_compound_p (enum tree_code);
 281 static tree search_loop (tree);
 282 static int labeled_block_contains_loop_p (tree, tree);
 283 static int check_abstract_method_definitions (int, tree, tree);
 284 static void java_check_abstract_method_definitions (tree);
 285 static void java_debug_context_do (int);
 286 static void java_parser_context_push_initialized_field (void);
 287 static void java_parser_context_pop_initialized_field (void);
 288 static tree reorder_static_initialized (tree);
 289 static void java_parser_context_suspend (void);
 290 static void java_parser_context_resume (void);
 291 static int pop_current_osb (struct parser_ctxt *);
 292
 293 /* JDK 1.1 work. FIXME */
 294
 295 static tree maybe_make_nested_class_name (tree);
 296 static int make_nested_class_name (tree);
 297 static void link_nested_class_to_enclosing (void);
 298 static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
 299 static tree find_as_inner_class (tree, tree, tree);
 300 static tree find_as_inner_class_do (tree, tree);
 301 static int check_inner_class_redefinition (tree, tree);
 302
 303 static tree build_thisn_assign (void);
 304 static tree build_current_thisn (tree);
 305 static tree build_access_to_thisn (tree, tree, int);
 306 static tree maybe_build_thisn_access_method (tree);
 307
 308 static tree build_outer_field_access (tree, tree);
 309 static tree build_outer_field_access_methods (tree);
 310 static tree build_outer_field_access_expr (int, tree, tree,
 311                                                   tree, tree);
 312 static tree build_outer_method_access_method (tree);
 313 static tree build_new_access_id (void);
 314 static tree build_outer_field_access_method (tree, tree, tree,
 315                                                     tree, tree);
 316
 317 static int outer_field_access_p (tree, tree);
 318 static int outer_field_expanded_access_p (tree, tree *,
 319                                                  tree *, tree *);
 320 static tree outer_field_access_fix (tree, tree, tree);
 321 static tree build_incomplete_class_ref (int, tree);
 322 static tree patch_incomplete_class_ref (tree);
 323 static tree create_anonymous_class (tree);
 324 static void patch_anonymous_class (tree, tree, tree);
 325 static void add_inner_class_fields (tree, tree);
 326
 327 static tree build_dot_class_method (tree);
 328 static tree build_dot_class_method_invocation (tree, tree);
 329 static void create_new_parser_context (int);
 330 static tree maybe_build_class_init_for_field (tree, tree);
 331
 332 static int attach_init_test_initialization_flags (void **, void *);
 333 static int emit_test_initialization (void **, void *);
 334
 335 static char *string_convert_int_cst (tree);
 336
 337 /* Number of error found so far. */
 338 int java_error_count;
 339 /* Number of warning found so far. */
 340 int java_warning_count;
 341 /* Tell when not to fold, when doing xrefs */
 342 int do_not_fold;
 343 /* Cyclic inheritance report, as it can be set by layout_class */
 344 const char *cyclic_inheritance_report;
 345
 346 /* The current parser context */
 347 struct parser_ctxt *ctxp;
 348
 349 /* List of things that were analyzed for which code will be generated */
 350 struct parser_ctxt *ctxp_for_generation = NULL;
 351
 352 /* binop_lookup maps token to tree_code. It is used where binary
 353    operations are involved and required by the parser. RDIV_EXPR
 354    covers both integral/floating point division. The code is changed
 355    once the type of both operator is worked out.  */
 356
 357 static const enum tree_code binop_lookup[19] =
 358   {
 359     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
 360     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
 361     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
 362     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
 363     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
 364    };
 365 #define BINOP_LOOKUP(VALUE)                                             \
 366   binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
 367
 368 /* This is the end index for binary operators that can also be used
 369    in compound assignments. */
 370 #define BINOP_COMPOUND_CANDIDATES 11
 371
 372 /* The "$L" identifier we use to create labels.  */
 373 static GTY(()) tree label_id;
 374
 375 /* The "StringBuffer" identifier used for the String `+' operator. */
 376 static GTY(()) tree wfl_string_buffer;
 377
 378 /* The "append" identifier used for String `+' operator.  */
 379 static GTY(()) tree wfl_append;
 380
 381 /* The "toString" identifier used for String `+' operator. */
 382 static GTY(()) tree wfl_to_string;
 383
 384 /* The "java.lang" import qualified name.  */
 385 static GTY(()) tree java_lang_id;
 386
 387 /* The generated `inst$' identifier used for generated enclosing
 388    instance/field access functions.  */
 389 static GTY(()) tree inst_id;
 390
 391 /* Context and flag for static blocks */
 392 static GTY(()) tree current_static_block;
 393
 394 /* The generated `write_parm_value$' identifier.  */
 395 static GTY(()) tree wpv_id;
 396
 397 /* The list of all packages we've seen so far */
 398 static GTY(()) tree package_list;
 399
 400 /* Hold THIS for the scope of the current method decl.  */
 401 static GTY(()) tree current_this;
 402
 403 /* Hold a list of catch clauses list. The first element of this list is
 404    the list of the catch clauses of the currently analyzed try block. */
 405 static GTY(()) tree currently_caught_type_list;
 406
 407 /* This holds a linked list of all the case labels for the current
 408    switch statement.  It is only used when checking to see if there
 409    are duplicate labels.  FIXME: probably this should just be attached
 410    to the switch itself; then it could be referenced via
 411    `ctxp->current_loop'.  */
 412 static GTY(()) tree case_label_list;
 413
 414 /* Anonymous class counter. Will be reset to 1 every time a non
 415    anonymous class gets created. */
 416 static int anonymous_class_counter = 1;
 417
 418 static GTY(()) tree src_parse_roots[1];
 419
 420 /* All classes seen from source code */
 421 #define gclass_list src_parse_roots[0]
 422
 423 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
 424    line and point it out.  */
 425 /* Should point out the one that don't fit. ASCII/unicode, going
 426    backward. FIXME */
 427
 428 #define check_modifiers(__message, __value, __mask) do {        \
 429   if ((__value) & ~(__mask))                                    \
 430     {                                                           \
 431       size_t i, remainder = (__value) & ~(__mask);              \
 432       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)     \
 433         if ((1 << i) & remainder)                               \
 434           parse_error_context (ctxp->modifier_ctx [i], (__message), \
 435                                java_accstring_lookup (1 << i)); \
 436     }                                                           \
 437 } while (0)
 438
 439 %}
 440
 441 %union {
 442   tree node;
 443   int sub_token;
 444   struct {
 445     int token;
 446     int location;
 447   } operator;
 448   int value;
 449 }
 450
 451 %{
 452 #include "lex.c"
 453 %}
 454
 455 %pure_parser
 456
 457 /* Things defined here have to match the order of what's in the
 458    binop_lookup table.  */
 459
 460 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
 461 %token   LS_TK           SRS_TK          ZRS_TK
 462 %token   AND_TK          XOR_TK          OR_TK
 463 %token   BOOL_AND_TK BOOL_OR_TK
 464 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
 465
 466 /* This maps to the same binop_lookup entry than the token above */
 467
 468 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
 469 %token   REM_ASSIGN_TK
 470 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 471 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
 472
 473
 474 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
 475
 476 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
 477 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
 478 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
 479 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
 480 %token   MODIFIER_TK
 481
 482 /* Keep those two in order, too */
 483 %token   DECR_TK INCR_TK
 484
 485 /* From now one, things can be in any order */
 486
 487 %token   DEFAULT_TK      IF_TK              THROW_TK
 488 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
 489 %token   THROWS_TK       BREAK_TK           IMPORT_TK
 490 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
 491 %token   VOID_TK         CATCH_TK           INTERFACE_TK
 492 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
 493 %token   SUPER_TK        WHILE_TK           CLASS_TK
 494 %token   SWITCH_TK       CONST_TK           TRY_TK
 495 %token   FOR_TK          NEW_TK             CONTINUE_TK
 496 %token   GOTO_TK         PACKAGE_TK         THIS_TK
 497 %token   ASSERT_TK
 498
 499 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
 500 %token   CHAR_TK         INTEGRAL_TK
 501
 502 %token   FLOAT_TK        DOUBLE_TK          FP_TK
 503
 504 %token   ID_TK
 505
 506 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
 507
 508 %token   ASSIGN_ANY_TK   ASSIGN_TK
 509 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
 510
 511 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
 512 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
 513
 514 %type    <value>        modifiers MODIFIER_TK final synchronized
 515
 516 %type    <node>         super ID_TK identifier
 517 %type    <node>         name simple_name qualified_name
 518 %type    <node>         type_declaration compilation_unit
 519                         field_declaration method_declaration extends_interfaces
 520                         interfaces interface_type_list
 521                         import_declarations package_declaration
 522                         type_declarations interface_body
 523                         interface_member_declaration constant_declaration
 524                         interface_member_declarations interface_type
 525                         abstract_method_declaration
 526 %type    <node>         class_body_declaration class_member_declaration
 527                         static_initializer constructor_declaration block
 528 %type    <node>         class_body_declarations constructor_header
 529 %type    <node>         class_or_interface_type class_type class_type_list
 530                         constructor_declarator explicit_constructor_invocation
 531 %type    <node>         dim_expr dim_exprs this_or_super throws
 532
 533 %type    <node>         variable_declarator_id variable_declarator
 534                         variable_declarators variable_initializer
 535                         variable_initializers constructor_body
 536                         array_initializer
 537
 538 %type    <node>         class_body block_end constructor_block_end
 539 %type    <node>         statement statement_without_trailing_substatement
 540                         labeled_statement if_then_statement label_decl
 541                         if_then_else_statement while_statement for_statement
 542                         statement_nsi labeled_statement_nsi do_statement
 543                         if_then_else_statement_nsi while_statement_nsi
 544                         for_statement_nsi statement_expression_list for_init
 545                         for_update statement_expression expression_statement
 546                         primary_no_new_array expression primary
 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 (!IS_EMPTY_STMT ($1))
 911                     {
 912                       TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
 913                       SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
 914                     }
 915                 }
 916 ;
 917
 918 class_member_declaration:
 919         field_declaration
 920 |       method_declaration
 921 |       class_declaration       /* Added, JDK1.1 inner classes */
 922                 { end_class_declaration (1); }
 923 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
 924                 { end_class_declaration (1); }
 925 |       empty_statement
 926 ;
 927
 928 /* 19.8.2 Productions from 8.3: Field Declarations  */
 929 field_declaration:
 930         type variable_declarators SC_TK
 931                 { register_fields (0, $1, $2); }
 932 |       modifiers type variable_declarators SC_TK
 933                 {
 934                   check_modifiers
 935                     ("Illegal modifier `%s' for field declaration",
 936                      $1, FIELD_MODIFIERS);
 937                   check_modifiers_consistency ($1);
 938                   register_fields ($1, $2, $3);
 939                 }
 940 ;
 941
 942 variable_declarators:
 943         /* Should we use build_decl_list () instead ? FIXME */
 944         variable_declarator     /* Default rule */
 945 |       variable_declarators C_TK variable_declarator
 946                 { $$ = chainon ($1, $3); }
 947 |       variable_declarators C_TK error
 948                 {yyerror ("Missing term"); RECOVER;}
 949 ;
 950
 951 variable_declarator:
 952         variable_declarator_id
 953                 { $$ = build_tree_list ($1, NULL_TREE); }
 954 |       variable_declarator_id ASSIGN_TK variable_initializer
 955                 {
 956                   if (java_error_count)
 957                     $3 = NULL_TREE;
 958                   $$ = build_tree_list
 959                     ($1, build_assignment ($2.token, $2.location, $1, $3));
 960                 }
 961 |       variable_declarator_id ASSIGN_TK error
 962                 {
 963                   yyerror ("Missing variable initializer");
 964                   $$ = build_tree_list ($1, NULL_TREE);
 965                   RECOVER;
 966                 }
 967 |       variable_declarator_id ASSIGN_TK variable_initializer error
 968                 {
 969                   yyerror ("';' expected");
 970                   $$ = build_tree_list ($1, NULL_TREE);
 971                   RECOVER;
 972                 }
 973 ;
 974
 975 variable_declarator_id:
 976         identifier
 977 |       variable_declarator_id OSB_TK CSB_TK
 978                 { $$ = build_unresolved_array_type ($1); }
 979 |       identifier error
 980                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
 981 |       variable_declarator_id OSB_TK error
 982                 {
 983                   yyerror ("']' expected");
 984                   DRECOVER(vdi);
 985                 }
 986 |       variable_declarator_id CSB_TK error
 987                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
 988 ;
 989
 990 variable_initializer:
 991         expression
 992 |       array_initializer
 993 ;
 994
 995 /* 19.8.3 Productions from 8.4: Method Declarations  */
 996 method_declaration:
 997         method_header
 998                 {
 999                   current_function_decl = $1;
1000                   if (current_function_decl
1001                       && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1002                     source_start_java_method (current_function_decl);
1003                   else
1004                     current_function_decl = NULL_TREE;
1005                 }
1006         method_body
1007                 { finish_method_declaration ($3); }
1008 |       method_header error
1009                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1010 ;
1011
1012 method_header:
1013         type method_declarator throws
1014                 { $$ = method_header (0, $1, $2, $3); }
1015 |       VOID_TK method_declarator throws
1016                 { $$ = method_header (0, void_type_node, $2, $3); }
1017 |       modifiers type method_declarator throws
1018                 { $$ = method_header ($1, $2, $3, $4); }
1019 |       modifiers VOID_TK method_declarator throws
1020                 { $$ = method_header ($1, void_type_node, $3, $4); }
1021 |       type error
1022                 {
1023                   yyerror ("Invalid method declaration, method name required");
1024                   RECOVER;
1025                 }
1026 |       modifiers type error
1027                 {
1028                   yyerror ("Identifier expected");
1029                   RECOVER;
1030                 }
1031 |       VOID_TK error
1032                 {
1033                   yyerror ("Identifier expected");
1034                   RECOVER;
1035                 }
1036 |       modifiers VOID_TK error
1037                 {
1038                   yyerror ("Identifier expected");
1039                   RECOVER;
1040                 }
1041 |       modifiers error
1042                 {
1043                   yyerror ("Invalid method declaration, return type required");
1044                   RECOVER;
1045                 }
1046 ;
1047
1048 method_declarator:
1049         identifier OP_TK CP_TK
1050                 {
1051                   ctxp->formal_parameter_number = 0;
1052                   $$ = method_declarator ($1, NULL_TREE);
1053                 }
1054 |       identifier OP_TK formal_parameter_list CP_TK
1055                 { $$ = method_declarator ($1, $3); }
1056 |       method_declarator OSB_TK CSB_TK
1057                 {
1058                   EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1059                   TREE_PURPOSE ($1) =
1060                     build_unresolved_array_type (TREE_PURPOSE ($1));
1061                   parse_warning_context
1062                     (wfl_operator,
1063                      "Discouraged form of returned type specification");
1064                 }
1065 |       identifier OP_TK error
1066                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1067 |       method_declarator OSB_TK error
1068                 {yyerror ("']' expected"); RECOVER;}
1069 ;
1070
1071 formal_parameter_list:
1072         formal_parameter
1073                 {
1074                   ctxp->formal_parameter_number = 1;
1075                 }
1076 |       formal_parameter_list C_TK formal_parameter
1077                 {
1078                   ctxp->formal_parameter_number += 1;
1079                   $$ = chainon ($1, $3);
1080                 }
1081 |       formal_parameter_list C_TK error
1082                 { yyerror ("Missing formal parameter term"); RECOVER; }
1083 ;
1084
1085 formal_parameter:
1086         type variable_declarator_id
1087                 {
1088                   $$ = build_tree_list ($2, $1);
1089                 }
1090 |       final type variable_declarator_id /* Added, JDK1.1 final parms */
1091                 {
1092                   $$ = build_tree_list ($3, $2);
1093                   ARG_FINAL_P ($$) = 1;
1094                 }
1095 |       type error
1096                 {
1097                   yyerror ("Missing identifier"); RECOVER;
1098                   $$ = NULL_TREE;
1099                 }
1100 |       final type error
1101                 {
1102                   yyerror ("Missing identifier"); RECOVER;
1103                   $$ = NULL_TREE;
1104                 }
1105 ;
1106
1107 final:
1108         modifiers
1109                 {
1110                   check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1111                                    $1, ACC_FINAL);
1112                   if ($1 != ACC_FINAL)
1113                     MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1114                 }
1115 ;
1116
1117 throws:
1118                 { $$ = NULL_TREE; }
1119 |       THROWS_TK class_type_list
1120                 { $$ = $2; }
1121 |       THROWS_TK error
1122                 {yyerror ("Missing class type term"); RECOVER;}
1123 ;
1124
1125 class_type_list:
1126         class_type
1127                 { $$ = build_tree_list ($1, $1); }
1128 |       class_type_list C_TK class_type
1129                 { $$ = tree_cons ($3, $3, $1); }
1130 |       class_type_list C_TK error
1131                 {yyerror ("Missing class type term"); RECOVER;}
1132 ;
1133
1134 method_body:
1135         block
1136 |       SC_TK { $$ = NULL_TREE; }
1137 ;
1138
1139 /* 19.8.4 Productions from 8.5: Static Initializers  */
1140 static_initializer:
1141         static block
1142                 {
1143                   TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1144                   SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1145                   current_static_block = NULL_TREE;
1146                 }
1147 ;
1148
1149 static:                         /* Test lval.sub_token here */
1150         modifiers
1151                 {
1152                   check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1153                   /* Can't have a static initializer in an innerclass */
1154                   if ($1 | ACC_STATIC &&
1155                       GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1156                     parse_error_context
1157                       (MODIFIER_WFL (STATIC_TK),
1158                        "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1159                        IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1160                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1161                 }
1162 ;
1163
1164 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1165 constructor_declaration:
1166         constructor_header
1167                 {
1168                   current_function_decl = $1;
1169                   source_start_java_method (current_function_decl);
1170                 }
1171         constructor_body
1172                 { finish_method_declaration ($3); }
1173 ;
1174
1175 constructor_header:
1176         constructor_declarator throws
1177                 { $$ = method_header (0, NULL_TREE, $1, $2); }
1178 |       modifiers constructor_declarator throws
1179                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1180 ;
1181
1182 constructor_declarator:
1183         simple_name OP_TK CP_TK
1184                 {
1185                   ctxp->formal_parameter_number = 0;
1186                   $$ = method_declarator ($1, NULL_TREE);
1187                 }
1188 |       simple_name OP_TK formal_parameter_list CP_TK
1189                 { $$ = method_declarator ($1, $3); }
1190 ;
1191
1192 constructor_body:
1193         /* Unlike regular method, we always need a complete (empty)
1194            body so we can safely perform all the required code
1195            addition (super invocation and field initialization) */
1196         block_begin constructor_block_end
1197                 {
1198                   BLOCK_EXPR_BODY ($2) = build_java_empty_stmt ();
1199                   $$ = $2;
1200                 }
1201 |       block_begin explicit_constructor_invocation constructor_block_end
1202                 { $$ = $3; }
1203 |       block_begin block_statements constructor_block_end
1204                 { $$ = $3; }
1205 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1206                 { $$ = $4; }
1207 ;
1208
1209 constructor_block_end:
1210         block_end
1211 ;
1212
1213 /* Error recovery for that rule moved down expression_statement: rule.  */
1214 explicit_constructor_invocation:
1215         this_or_super OP_TK CP_TK SC_TK
1216                 {
1217                   $$ = build_method_invocation ($1, NULL_TREE);
1218                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1219                   $$ = java_method_add_stmt (current_function_decl, $$);
1220                 }
1221 |       this_or_super OP_TK argument_list CP_TK SC_TK
1222                 {
1223                   $$ = build_method_invocation ($1, $3);
1224                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1225                   $$ = java_method_add_stmt (current_function_decl, $$);
1226                 }
1227         /* Added, JDK1.1 inner classes. Modified because the rule
1228            'primary' couldn't work.  */
1229 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1230                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1231 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1232                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1233 ;
1234
1235 this_or_super:                  /* Added, simplifies error diagnostics */
1236         THIS_TK
1237                 {
1238                   tree wfl = build_wfl_node (this_identifier_node);
1239                   EXPR_WFL_LINECOL (wfl) = $1.location;
1240                   $$ = wfl;
1241                 }
1242 |       SUPER_TK
1243                 {
1244                   tree wfl = build_wfl_node (super_identifier_node);
1245                   EXPR_WFL_LINECOL (wfl) = $1.location;
1246                   $$ = wfl;
1247                 }
1248 ;
1249
1250 /* 19.9 Productions from 9: Interfaces  */
1251 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1252 interface_declaration:
1253         INTERFACE_TK identifier
1254                 { create_interface (0, $2, NULL_TREE); }
1255         interface_body
1256                 { ; }
1257 |       modifiers INTERFACE_TK identifier
1258                 { create_interface ($1, $3, NULL_TREE); }
1259         interface_body
1260                 { ; }
1261 |       INTERFACE_TK identifier extends_interfaces
1262                 { create_interface (0, $2, $3); }
1263         interface_body
1264                 { ; }
1265 |       modifiers INTERFACE_TK identifier extends_interfaces
1266                 { create_interface ($1, $3, $4); }
1267         interface_body
1268                 { ; }
1269 |       INTERFACE_TK identifier error
1270                 { yyerror ("'{' expected"); RECOVER; }
1271 |       modifiers INTERFACE_TK identifier error
1272                 { yyerror ("'{' expected"); RECOVER; }
1273 ;
1274
1275 extends_interfaces:
1276         EXTENDS_TK interface_type
1277                 {
1278                   ctxp->interface_number = 1;
1279                   $$ = build_tree_list ($2, NULL_TREE);
1280                 }
1281 |       extends_interfaces C_TK interface_type
1282                 {
1283                   ctxp->interface_number++;
1284                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1285                 }
1286 |       EXTENDS_TK error
1287                 {yyerror ("Invalid interface type"); RECOVER;}
1288 |       extends_interfaces C_TK error
1289                 {yyerror ("Missing term"); RECOVER;}
1290 ;
1291
1292 interface_body:
1293         OCB_TK CCB_TK
1294                 { $$ = NULL_TREE; }
1295 |       OCB_TK interface_member_declarations CCB_TK
1296                 { $$ = NULL_TREE; }
1297 ;
1298
1299 interface_member_declarations:
1300         interface_member_declaration
1301 |       interface_member_declarations interface_member_declaration
1302 ;
1303
1304 interface_member_declaration:
1305         constant_declaration
1306 |       abstract_method_declaration
1307 |       class_declaration       /* Added, JDK1.1 inner classes */
1308                 { end_class_declaration (1); }
1309 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
1310                 { end_class_declaration (1); }
1311 ;
1312
1313 constant_declaration:
1314         field_declaration
1315 ;
1316
1317 abstract_method_declaration:
1318         method_header SC_TK
1319                 {
1320                   check_abstract_method_header ($1);
1321                   current_function_decl = NULL_TREE; /* FIXME ? */
1322                 }
1323 |       method_header error
1324                 {yyerror ("';' expected"); RECOVER;}
1325 ;
1326
1327 /* 19.10 Productions from 10: Arrays  */
1328 array_initializer:
1329         OCB_TK CCB_TK
1330                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1331 |       OCB_TK C_TK CCB_TK
1332                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1333 |       OCB_TK variable_initializers CCB_TK
1334                 { $$ = build_new_array_init ($1.location, $2); }
1335 |       OCB_TK variable_initializers C_TK CCB_TK
1336                 { $$ = build_new_array_init ($1.location, $2); }
1337 ;
1338
1339 variable_initializers:
1340         variable_initializer
1341                 {
1342                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1343                                   $1, NULL_TREE);
1344                 }
1345 |       variable_initializers C_TK variable_initializer
1346                 {
1347                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1348                 }
1349 |       variable_initializers C_TK error
1350                 {yyerror ("Missing term"); RECOVER;}
1351 ;
1352
1353 /* 19.11 Production from 14: Blocks and Statements  */
1354 block:
1355         block_begin block_end
1356                 { $$ = $2; }
1357 |       block_begin block_statements block_end
1358                 { $$ = $3; }
1359 ;
1360
1361 block_begin:
1362         OCB_TK
1363                 { enter_block (); }
1364 ;
1365
1366 block_end:
1367         CCB_TK
1368                 {
1369                   maybe_absorb_scoping_blocks ();
1370                   /* Store the location of the `}' when doing xrefs */
1371                   if (current_function_decl && flag_emit_xref)
1372                     DECL_END_SOURCE_LINE (current_function_decl) =
1373                       EXPR_WFL_ADD_COL ($1.location, 1);
1374                   $$ = exit_block ();
1375                   if (!BLOCK_SUBBLOCKS ($$))
1376                     BLOCK_SUBBLOCKS ($$) = build_java_empty_stmt ();
1377                 }
1378 ;
1379
1380 block_statements:
1381         block_statement
1382 |       block_statements block_statement
1383 ;
1384
1385 block_statement:
1386         local_variable_declaration_statement
1387 |       statement
1388                 { java_method_add_stmt (current_function_decl, $1); }
1389 |       class_declaration       /* Added, JDK1.1 local classes */
1390                 {
1391                   LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1392                   end_class_declaration (1);
1393                 }
1394 ;
1395
1396 local_variable_declaration_statement:
1397         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1398 ;
1399
1400 local_variable_declaration:
1401         type variable_declarators
1402                 { declare_local_variables (0, $1, $2); }
1403 |       final type variable_declarators /* Added, JDK1.1 final locals */
1404                 { declare_local_variables ($1, $2, $3); }
1405 ;
1406
1407 statement:
1408         statement_without_trailing_substatement
1409 |       labeled_statement
1410 |       if_then_statement
1411 |       if_then_else_statement
1412 |       while_statement
1413 |       for_statement
1414                 { $$ = exit_block (); }
1415 ;
1416
1417 statement_nsi:
1418         statement_without_trailing_substatement
1419 |       labeled_statement_nsi
1420 |       if_then_else_statement_nsi
1421 |       while_statement_nsi
1422 |       for_statement_nsi
1423                 { $$ = exit_block (); }
1424 ;
1425
1426 statement_without_trailing_substatement:
1427         block
1428 |       empty_statement
1429 |       expression_statement
1430 |       switch_statement
1431 |       do_statement
1432 |       break_statement
1433 |       continue_statement
1434 |       return_statement
1435 |       synchronized_statement
1436 |       throw_statement
1437 |       try_statement
1438 |       assert_statement
1439 ;
1440
1441 empty_statement:
1442         SC_TK
1443                 {
1444                   if (flag_extraneous_semicolon
1445                       && ! current_static_block
1446                       && (! current_function_decl ||
1447                           /* Verify we're not in a inner class declaration */
1448                           (GET_CPC () != TYPE_NAME
1449                            (DECL_CONTEXT (current_function_decl)))))
1450
1451                     {
1452                       EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1453                       parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1454                     }
1455                   $$ = build_java_empty_stmt ();
1456                 }
1457 ;
1458
1459 label_decl:
1460         identifier REL_CL_TK
1461                 {
1462                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1463                                             EXPR_WFL_NODE ($1));
1464                   pushlevel (2);
1465                   push_labeled_block ($$);
1466                   PUSH_LABELED_BLOCK ($$);
1467                 }
1468 ;
1469
1470 labeled_statement:
1471         label_decl statement
1472                 { $$ = finish_labeled_statement ($1, $2); }
1473 |       identifier error
1474                 {yyerror ("':' expected"); RECOVER;}
1475 ;
1476
1477 labeled_statement_nsi:
1478         label_decl statement_nsi
1479                 { $$ = finish_labeled_statement ($1, $2); }
1480 ;
1481
1482 /* We concentrate here a bunch of error handling rules that we couldn't write
1483    earlier, because expression_statement catches a missing ';'.  */
1484 expression_statement:
1485         statement_expression SC_TK
1486                 {
1487                   /* We have a statement. Generate a WFL around it so
1488                      we can debug it */
1489                   $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1490                   /* We know we have a statement, so set the debug
1491                      info to be eventually generate here. */
1492                   $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1493                 }
1494 |       error SC_TK
1495                 {
1496                   YYNOT_TWICE yyerror ("Invalid expression statement");
1497                   DRECOVER (expr_stmt);
1498                 }
1499 |       error OCB_TK
1500                 {
1501                   YYNOT_TWICE yyerror ("Invalid expression statement");
1502                   DRECOVER (expr_stmt);
1503                 }
1504 |       error CCB_TK
1505                 {
1506                   YYNOT_TWICE yyerror ("Invalid expression statement");
1507                   DRECOVER (expr_stmt);
1508                 }
1509 |       this_or_super OP_TK error
1510                 {yyerror ("')' expected"); RECOVER;}
1511 |       this_or_super OP_TK CP_TK error
1512                 {
1513                   parse_ctor_invocation_error ();
1514                   RECOVER;
1515                 }
1516 |       this_or_super OP_TK argument_list error
1517                 {yyerror ("')' expected"); RECOVER;}
1518 |       this_or_super OP_TK argument_list CP_TK error
1519                 {
1520                   parse_ctor_invocation_error ();
1521                   RECOVER;
1522                 }
1523 |       name DOT_TK SUPER_TK error
1524                 {yyerror ("'(' expected"); RECOVER;}
1525 |       name DOT_TK SUPER_TK OP_TK error
1526                 {yyerror ("')' expected"); RECOVER;}
1527 |       name DOT_TK SUPER_TK OP_TK argument_list error
1528                 {yyerror ("')' expected"); RECOVER;}
1529 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1530                 {yyerror ("';' expected"); RECOVER;}
1531 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1532                 {yyerror ("';' expected"); RECOVER;}
1533 ;
1534
1535 statement_expression:
1536         assignment
1537 |       pre_increment_expression
1538 |       pre_decrement_expression
1539 |       post_increment_expression
1540 |       post_decrement_expression
1541 |       method_invocation
1542 |       class_instance_creation_expression
1543 ;
1544
1545 if_then_statement:
1546         IF_TK OP_TK expression CP_TK statement
1547                 {
1548                   $$ = build_if_else_statement ($2.location, $3,
1549                                                 $5, NULL_TREE);
1550                 }
1551 |       IF_TK error
1552                 {yyerror ("'(' expected"); RECOVER;}
1553 |       IF_TK OP_TK error
1554                 {yyerror ("Missing term"); RECOVER;}
1555 |       IF_TK OP_TK expression error
1556                 {yyerror ("')' expected"); RECOVER;}
1557 ;
1558
1559 if_then_else_statement:
1560         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1561                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1562 ;
1563
1564 if_then_else_statement_nsi:
1565         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1566                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1567 ;
1568
1569 switch_statement:
1570         switch_expression
1571                 {
1572                   enter_block ();
1573                 }
1574         switch_block
1575                 {
1576                   /* Make into "proper list" of COMPOUND_EXPRs.
1577                      I.e. make the last statement also have its own
1578                      COMPOUND_EXPR. */
1579                   maybe_absorb_scoping_blocks ();
1580                   TREE_OPERAND ($1, 1) = exit_block ();
1581                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1582                 }
1583 ;
1584
1585 switch_expression:
1586         SWITCH_TK OP_TK expression CP_TK
1587                 {
1588                   $$ = build3 (SWITCH_EXPR, NULL_TREE, $3,
1589                                NULL_TREE, NULL_TREE);
1590                   EXPR_WFL_LINECOL ($$) = $2.location;
1591                 }
1592 |       SWITCH_TK error
1593                 {yyerror ("'(' expected"); RECOVER;}
1594 |       SWITCH_TK OP_TK error
1595                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1596 |       SWITCH_TK OP_TK expression CP_TK error
1597                 {yyerror ("'{' expected"); RECOVER;}
1598 ;
1599
1600 /* Default assignment is there to avoid type node on switch_block
1601    node. */
1602
1603 switch_block:
1604         OCB_TK CCB_TK
1605                 { $$ = NULL_TREE; }
1606 |       OCB_TK switch_labels CCB_TK
1607                 { $$ = NULL_TREE; }
1608 |       OCB_TK switch_block_statement_groups CCB_TK
1609                 { $$ = NULL_TREE; }
1610 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1611                 { $$ = NULL_TREE; }
1612 ;
1613
1614 switch_block_statement_groups:
1615         switch_block_statement_group
1616 |       switch_block_statement_groups switch_block_statement_group
1617 ;
1618
1619 switch_block_statement_group:
1620         switch_labels block_statements
1621 ;
1622
1623 switch_labels:
1624         switch_label
1625 |       switch_labels switch_label
1626 ;
1627
1628 switch_label:
1629         CASE_TK constant_expression REL_CL_TK
1630                 {
1631                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1632                   EXPR_WFL_LINECOL (lab) = $1.location;
1633                   java_method_add_stmt (current_function_decl, lab);
1634                 }
1635 |       DEFAULT_TK REL_CL_TK
1636                 {
1637                   tree lab = make_node (DEFAULT_EXPR);
1638                   EXPR_WFL_LINECOL (lab) = $1.location;
1639                   java_method_add_stmt (current_function_decl, lab);
1640                 }
1641 |       CASE_TK error
1642                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1643 |       CASE_TK constant_expression error
1644                 {yyerror ("':' expected"); RECOVER;}
1645 |       DEFAULT_TK error
1646                 {yyerror ("':' expected"); RECOVER;}
1647 ;
1648
1649 while_expression:
1650         WHILE_TK OP_TK expression CP_TK
1651                 {
1652                   tree body = build_loop_body ($2.location, $3, 0);
1653                   $$ = build_new_loop (body);
1654                 }
1655 ;
1656
1657 while_statement:
1658         while_expression statement
1659                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1660 |       WHILE_TK error
1661                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1662 |       WHILE_TK OP_TK error
1663                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1664 |       WHILE_TK OP_TK expression error
1665                 {yyerror ("')' expected"); RECOVER;}
1666 ;
1667
1668 while_statement_nsi:
1669         while_expression statement_nsi
1670                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1671 ;
1672
1673 do_statement_begin:
1674         DO_TK
1675                 {
1676                   tree body = build_loop_body (0, NULL_TREE, 1);
1677                   $$ = build_new_loop (body);
1678                 }
1679         /* Need error handing here. FIXME */
1680 ;
1681
1682 do_statement:
1683         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1684                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1685 ;
1686
1687 for_statement:
1688         for_begin SC_TK expression SC_TK for_update CP_TK statement
1689                 {
1690                   if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1691                     $3 = build_wfl_node ($3);
1692                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1693                 }
1694 |       for_begin SC_TK SC_TK for_update CP_TK statement
1695                 {
1696                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1697                   /* We have not condition, so we get rid of the EXIT_EXPR */
1698                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1699                     build_java_empty_stmt ();
1700                 }
1701 |       for_begin SC_TK error
1702                 {yyerror ("Invalid control expression"); RECOVER;}
1703 |       for_begin SC_TK expression SC_TK error
1704                 {yyerror ("Invalid update expression"); RECOVER;}
1705 |       for_begin SC_TK SC_TK error
1706                 {yyerror ("Invalid update expression"); RECOVER;}
1707 ;
1708
1709 for_statement_nsi:
1710         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1711                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1712 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1713                 {
1714                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1715                   /* We have not condition, so we get rid of the EXIT_EXPR */
1716                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1717                     build_java_empty_stmt ();
1718                 }
1719 ;
1720
1721 for_header:
1722         FOR_TK OP_TK
1723                 {
1724                   /* This scope defined for local variable that may be
1725                      defined within the scope of the for loop */
1726                   enter_block ();
1727                 }
1728 |       FOR_TK error
1729                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1730 |       FOR_TK OP_TK error
1731                 {yyerror ("Invalid init statement"); RECOVER;}
1732 ;
1733
1734 for_begin:
1735         for_header for_init
1736                 {
1737                   /* We now declare the loop body. The loop is
1738                      declared as a for loop. */
1739                   tree body = build_loop_body (0, NULL_TREE, 0);
1740                   $$ =  build_new_loop (body);
1741                   FOR_LOOP_P ($$) = 1;
1742                   /* The loop is added to the current block the for
1743                      statement is defined within */
1744                   java_method_add_stmt (current_function_decl, $$);
1745                 }
1746 ;
1747 for_init:                       /* Can be empty */
1748                 { $$ = build_java_empty_stmt (); }
1749 |       statement_expression_list
1750                 {
1751                   /* Init statement recorded within the previously
1752                      defined block scope */
1753                   $$ = java_method_add_stmt (current_function_decl, $1);
1754                 }
1755 |       local_variable_declaration
1756                 {
1757                   /* Local variable are recorded within the previously
1758                      defined block scope */
1759                   $$ = NULL_TREE;
1760                 }
1761 |       statement_expression_list error
1762                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1763 ;
1764
1765 for_update:                     /* Can be empty */
1766                 {$$ = build_java_empty_stmt ();}
1767 |       statement_expression_list
1768                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1769 ;
1770
1771 statement_expression_list:
1772         statement_expression
1773                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1774 |       statement_expression_list C_TK statement_expression
1775                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1776 |       statement_expression_list C_TK error
1777                 {yyerror ("Missing term"); RECOVER;}
1778 ;
1779
1780 break_statement:
1781         BREAK_TK SC_TK
1782                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1783 |       BREAK_TK identifier SC_TK
1784                 { $$ = build_bc_statement ($1.location, 1, $2); }
1785 |       BREAK_TK error
1786                 {yyerror ("Missing term"); RECOVER;}
1787 |       BREAK_TK identifier error
1788                 {yyerror ("';' expected"); RECOVER;}
1789 ;
1790
1791 continue_statement:
1792         CONTINUE_TK SC_TK
1793                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1794 |       CONTINUE_TK identifier SC_TK
1795                 { $$ = build_bc_statement ($1.location, 0, $2); }
1796 |       CONTINUE_TK error
1797                 {yyerror ("Missing term"); RECOVER;}
1798 |       CONTINUE_TK identifier error
1799                 {yyerror ("';' expected"); RECOVER;}
1800 ;
1801
1802 return_statement:
1803         RETURN_TK SC_TK
1804                 { $$ = build_return ($1.location, NULL_TREE); }
1805 |       RETURN_TK expression SC_TK
1806                 { $$ = build_return ($1.location, $2); }
1807 |       RETURN_TK error
1808                 {yyerror ("Missing term"); RECOVER;}
1809 |       RETURN_TK expression error
1810                 {yyerror ("';' expected"); RECOVER;}
1811 ;
1812
1813 throw_statement:
1814         THROW_TK expression SC_TK
1815                 {
1816                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1817                   EXPR_WFL_LINECOL ($$) = $1.location;
1818                 }
1819 |       THROW_TK error
1820                 {yyerror ("Missing term"); RECOVER;}
1821 |       THROW_TK expression error
1822                 {yyerror ("';' expected"); RECOVER;}
1823 ;
1824
1825 assert_statement:
1826         ASSERT_TK expression REL_CL_TK expression SC_TK
1827                 {
1828                   $$ = build_assertion ($1.location, $2, $4);
1829                 }
1830 |       ASSERT_TK expression SC_TK
1831                 {
1832                   $$ = build_assertion ($1.location, $2, NULL_TREE);
1833                 }
1834 |       ASSERT_TK error
1835                 {yyerror ("Missing term"); RECOVER;}
1836 |       ASSERT_TK expression error
1837                 {yyerror ("';' expected"); RECOVER;}
1838 ;
1839
1840 synchronized_statement:
1841         synchronized OP_TK expression CP_TK block
1842                 {
1843                   $$ = build2 (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1844                   EXPR_WFL_LINECOL ($$) =
1845                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1846                 }
1847 |       synchronized OP_TK expression CP_TK error
1848                 {yyerror ("'{' expected"); RECOVER;}
1849 |       synchronized error
1850                 {yyerror ("'(' expected"); RECOVER;}
1851 |       synchronized OP_TK error CP_TK
1852                 {yyerror ("Missing term"); RECOVER;}
1853 |       synchronized OP_TK error
1854                 {yyerror ("Missing term"); RECOVER;}
1855 ;
1856
1857 synchronized:
1858         modifiers
1859                 {
1860                   check_modifiers (
1861              "Illegal modifier `%s'. Only `synchronized' was expected here",
1862                                    $1, ACC_SYNCHRONIZED);
1863                   if ($1 != ACC_SYNCHRONIZED)
1864                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1865                       build_wfl_node (NULL_TREE);
1866                 }
1867 ;
1868
1869 try_statement:
1870         TRY_TK block catches
1871                 { $$ = build_try_statement ($1.location, $2, $3); }
1872 |       TRY_TK block finally
1873                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1874 |       TRY_TK block catches finally
1875                 { $$ = build_try_finally_statement
1876                     ($1.location, build_try_statement ($1.location,
1877                                                        $2, $3), $4);
1878                 }
1879 |       TRY_TK error
1880                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1881 ;
1882
1883 catches:
1884         catch_clause
1885 |       catches catch_clause
1886                 {
1887                   TREE_CHAIN ($2) = $1;
1888                   $$ = $2;
1889                 }
1890 ;
1891
1892 catch_clause:
1893         catch_clause_parameter block
1894                 {
1895                   java_method_add_stmt (current_function_decl, $2);
1896                   exit_block ();
1897                   $$ = $1;
1898                 }
1899 ;
1900
1901 catch_clause_parameter:
1902         CATCH_TK OP_TK formal_parameter CP_TK
1903                 {
1904                   /* We add a block to define a scope for
1905                      formal_parameter (CCBP). The formal parameter is
1906                      declared initialized by the appropriate function
1907                      call */
1908                   tree ccpb;
1909                   tree init;
1910                   if ($3)
1911                     {
1912                       ccpb = enter_block ();
1913                       init = build_assignment
1914                         (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1915                          build0 (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1916                       declare_local_variables (0, TREE_VALUE ($3),
1917                                                build_tree_list
1918                                                (TREE_PURPOSE ($3), init));
1919                       $$ = build1 (JAVA_CATCH_EXPR, NULL_TREE, ccpb);
1920                       EXPR_WFL_LINECOL ($$) = $1.location;
1921                     }
1922                   else
1923                     {
1924                       $$ = error_mark_node;
1925                     }
1926                 }
1927 |       CATCH_TK error
1928                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1929 |       CATCH_TK OP_TK error
1930                 {
1931                   yyerror ("Missing term or ')' expected");
1932                   RECOVER; $$ = NULL_TREE;
1933                 }
1934 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1935                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1936 ;
1937
1938 finally:
1939         FINALLY_TK block
1940                 { $$ = $2; }
1941 |       FINALLY_TK error
1942                 {yyerror ("'{' expected"); RECOVER; }
1943 ;
1944
1945 /* 19.12 Production from 15: Expressions  */
1946 primary:
1947         primary_no_new_array
1948 |       array_creation_expression
1949 ;
1950
1951 primary_no_new_array:
1952         literal
1953 |       THIS_TK
1954                 { $$ = build_this ($1.location); }
1955 |       OP_TK expression CP_TK
1956                 {$$ = $2;}
1957 |       class_instance_creation_expression
1958 |       field_access
1959 |       method_invocation
1960 |       array_access
1961 |       type_literals
1962         /* Added, JDK1.1 inner classes. Documentation is wrong
1963            refering to a 'ClassName' (class_name) rule that doesn't
1964            exist. Used name: instead.  */
1965 |       name DOT_TK THIS_TK
1966                 {
1967                   tree wfl = build_wfl_node (this_identifier_node);
1968                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1969                 }
1970 |       OP_TK expression error
1971                 {yyerror ("')' expected"); RECOVER;}
1972 |       name DOT_TK error
1973                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1974 |       primitive_type DOT_TK error
1975                 {yyerror ("'class' expected" ); RECOVER;}
1976 |       VOID_TK DOT_TK error
1977                 {yyerror ("'class' expected" ); RECOVER;}
1978 ;
1979
1980 type_literals:
1981         name DOT_TK CLASS_TK
1982                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1983 |       array_type DOT_TK CLASS_TK
1984                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1985 |       primitive_type DOT_TK CLASS_TK
1986                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1987 |       VOID_TK DOT_TK CLASS_TK
1988                 {
1989                    $$ = build_incomplete_class_ref ($2.location,
1990                                                    void_type_node);
1991                 }
1992 ;
1993
1994 class_instance_creation_expression:
1995         NEW_TK class_type OP_TK argument_list CP_TK
1996                 { $$ = build_new_invocation ($2, $4); }
1997 |       NEW_TK class_type OP_TK CP_TK
1998                 { $$ = build_new_invocation ($2, NULL_TREE); }
1999 |       anonymous_class_creation
2000         /* Added, JDK1.1 inner classes, modified to use name or
2001            primary instead of primary solely which couldn't work in
2002            all situations.  */
2003 |       something_dot_new identifier OP_TK CP_TK
2004                 {
2005                   tree ctor = build_new_invocation ($2, NULL_TREE);
2006                   $$ = make_qualified_primary ($1, ctor,
2007                                                EXPR_WFL_LINECOL ($1));
2008                 }
2009 |       something_dot_new identifier OP_TK CP_TK class_body
2010 |       something_dot_new identifier OP_TK argument_list CP_TK
2011                 {
2012                   tree ctor = build_new_invocation ($2, $4);
2013                   $$ = make_qualified_primary ($1, ctor,
2014                                                EXPR_WFL_LINECOL ($1));
2015                 }
2016 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2017 |       NEW_TK error SC_TK
2018                 {yyerror ("'(' expected"); DRECOVER(new_1);}
2019 |       NEW_TK class_type error
2020                 {yyerror ("'(' expected"); RECOVER;}
2021 |       NEW_TK class_type OP_TK error
2022                 {yyerror ("')' or term expected"); RECOVER;}
2023 |       NEW_TK class_type OP_TK argument_list error
2024                 {yyerror ("')' expected"); RECOVER;}
2025 |       something_dot_new error
2026                 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2027 |       something_dot_new identifier error
2028                 {yyerror ("'(' expected"); RECOVER;}
2029 ;
2030
2031 /* Created after JDK1.1 rules originally added to
2032    class_instance_creation_expression, but modified to use
2033    'class_type' instead of 'TypeName' (type_name) which is mentioned
2034    in the documentation but doesn't exist. */
2035
2036 anonymous_class_creation:
2037         NEW_TK class_type OP_TK argument_list CP_TK
2038                 { create_anonymous_class ($2); }
2039         class_body
2040                 {
2041                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2042                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2043
2044                   end_class_declaration (1);
2045
2046                   /* Now we can craft the new expression */
2047                   $$ = build_new_invocation (id, $4);
2048
2049                   /* Note that we can't possibly be here if
2050                      `class_type' is an interface (in which case the
2051                      anonymous class extends Object and implements
2052                      `class_type', hence its constructor can't have
2053                      arguments.) */
2054
2055                   /* Otherwise, the innerclass must feature a
2056                      constructor matching `argument_list'. Anonymous
2057                      classes are a bit special: it's impossible to
2058                      define constructor for them, hence constructors
2059                      must be generated following the hints provided by
2060                      the `new' expression. Whether a super constructor
2061                      of that nature exists or not is to be verified
2062                      later on in verify_constructor_super.
2063
2064                      It's during the expansion of a `new' statement
2065                      refering to an anonymous class that a ctor will
2066                      be generated for the anonymous class, with the
2067                      right arguments. */
2068
2069                 }
2070 |       NEW_TK class_type OP_TK CP_TK
2071                 { create_anonymous_class ($2); }
2072         class_body
2073                 {
2074                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2075                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2076
2077                   end_class_declaration (1);
2078
2079                   /* Now we can craft the new expression. The
2080                      statement doesn't need to be remember so that a
2081                      constructor can be generated, since its signature
2082                      is already known. */
2083                   $$ = build_new_invocation (id, NULL_TREE);
2084                 }
2085 ;
2086
2087 something_dot_new:              /* Added, not part of the specs. */
2088         name DOT_TK NEW_TK
2089                 { $$ = $1; }
2090 |       primary DOT_TK NEW_TK
2091                 { $$ = $1; }
2092 ;
2093
2094 argument_list:
2095         expression
2096                 {
2097                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2098                   ctxp->formal_parameter_number = 1;
2099                 }
2100 |       argument_list C_TK expression
2101                 {
2102                   ctxp->formal_parameter_number += 1;
2103                   $$ = tree_cons (NULL_TREE, $3, $1);
2104                 }
2105 |       argument_list C_TK error
2106                 {yyerror ("Missing term"); RECOVER;}
2107 ;
2108
2109 array_creation_expression:
2110         NEW_TK primitive_type dim_exprs
2111                 { $$ = build_newarray_node ($2, $3, 0); }
2112 |       NEW_TK class_or_interface_type dim_exprs
2113                 { $$ = build_newarray_node ($2, $3, 0); }
2114 |       NEW_TK primitive_type dim_exprs dims
2115                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2116 |       NEW_TK class_or_interface_type dim_exprs dims
2117                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2118         /* Added, JDK1.1 anonymous array. Initial documentation rule
2119            modified */
2120 |       NEW_TK class_or_interface_type dims array_initializer
2121                 {
2122                   char *sig;
2123                   int osb = pop_current_osb (ctxp);
2124                   while (osb--)
2125                     obstack_grow (&temporary_obstack, "[]", 2);
2126                   obstack_1grow (&temporary_obstack, '\0');
2127                   sig = obstack_finish (&temporary_obstack);
2128                   $$ = build3 (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2129                                $2, get_identifier (sig), $4);
2130                 }
2131 |       NEW_TK primitive_type dims array_initializer
2132                 {
2133                   int osb = pop_current_osb (ctxp);
2134                   tree type = $2;
2135                   while (osb--)
2136                     type = build_java_array_type (type, -1);
2137                   $$ = build3 (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2138                                build_pointer_type (type), NULL_TREE, $4);
2139                 }
2140 |       NEW_TK error CSB_TK
2141                 {yyerror ("'[' expected"); DRECOVER ("]");}
2142 |       NEW_TK error OSB_TK
2143                 {yyerror ("']' expected"); RECOVER;}
2144 ;
2145
2146 dim_exprs:
2147         dim_expr
2148                 { $$ = build_tree_list (NULL_TREE, $1); }
2149 |       dim_exprs dim_expr
2150                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2151 ;
2152
2153 dim_expr:
2154         OSB_TK expression CSB_TK
2155                 {
2156                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2157                     {
2158                       $2 = build_wfl_node ($2);
2159                       TREE_TYPE ($2) = NULL_TREE;
2160                     }
2161                   EXPR_WFL_LINECOL ($2) = $1.location;
2162                   $$ = $2;
2163                 }
2164 |       OSB_TK expression error
2165                 {yyerror ("']' expected"); RECOVER;}
2166 |       OSB_TK error
2167                 {
2168                   yyerror ("Missing term");
2169                   yyerror ("']' expected");
2170                   RECOVER;
2171                 }
2172 ;
2173
2174 dims:
2175         OSB_TK CSB_TK
2176                 {
2177                   int allocate = 0;
2178                   /* If not initialized, allocate memory for the osb
2179                      numbers stack */
2180                   if (!ctxp->osb_limit)
2181                     {
2182                       allocate = ctxp->osb_limit = 32;
2183                       ctxp->osb_depth = -1;
2184                     }
2185                   /* If capacity overflown, reallocate a bigger chunk */
2186                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2187                     allocate = ctxp->osb_limit << 1;
2188
2189                   if (allocate)
2190                     {
2191                       allocate *= sizeof (int);
2192                       if (ctxp->osb_number)
2193                         ctxp->osb_number = xrealloc (ctxp->osb_number,
2194                                                      allocate);
2195                       else
2196                         ctxp->osb_number = xmalloc (allocate);
2197                     }
2198                   ctxp->osb_depth++;
2199                   CURRENT_OSB (ctxp) = 1;
2200                 }
2201 |       dims OSB_TK CSB_TK
2202                 { CURRENT_OSB (ctxp)++; }
2203 |       dims OSB_TK error
2204                 { yyerror ("']' expected"); RECOVER;}
2205 ;
2206
2207 field_access:
2208         primary DOT_TK identifier
2209                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2210                 /*  FIXME - REWRITE TO:
2211                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2212 |       SUPER_TK DOT_TK identifier
2213                 {
2214                   tree super_wfl = build_wfl_node (super_identifier_node);
2215                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
2216                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2217                 }
2218 |       SUPER_TK error
2219                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2220 ;
2221
2222 method_invocation:
2223         name OP_TK CP_TK
2224                 { $$ = build_method_invocation ($1, NULL_TREE); }
2225 |       name OP_TK argument_list CP_TK
2226                 { $$ = build_method_invocation ($1, $3); }
2227 |       primary DOT_TK identifier OP_TK CP_TK
2228                 {
2229                   if (TREE_CODE ($1) == THIS_EXPR)
2230                     $$ = build_this_super_qualified_invocation
2231                       (1, $3, NULL_TREE, 0, $2.location);
2232                   else
2233                     {
2234                       tree invok = build_method_invocation ($3, NULL_TREE);
2235                       $$ = make_qualified_primary ($1, invok, $2.location);
2236                     }
2237                 }
2238 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2239                 {
2240                   if (TREE_CODE ($1) == THIS_EXPR)
2241                     $$ = build_this_super_qualified_invocation
2242                       (1, $3, $5, 0, $2.location);
2243                   else
2244                     {
2245                       tree invok = build_method_invocation ($3, $5);
2246                       $$ = make_qualified_primary ($1, invok, $2.location);
2247                     }
2248                 }
2249 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2250                 {
2251                   $$ = build_this_super_qualified_invocation
2252                     (0, $3, NULL_TREE, $1.location, $2.location);
2253                 }
2254 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2255                 {
2256                   $$ = build_this_super_qualified_invocation
2257                     (0, $3, $5, $1.location, $2.location);
2258                 }
2259         /* Screws up thing. I let it here until I'm convinced it can
2260            be removed. FIXME
2261 |       primary DOT_TK error
2262                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2263 |       SUPER_TK DOT_TK error CP_TK
2264                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2265 |       SUPER_TK DOT_TK error DOT_TK
2266                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2267 ;
2268
2269 array_access:
2270         name OSB_TK expression CSB_TK
2271                 { $$ = build_array_ref ($2.location, $1, $3); }
2272 |       primary_no_new_array OSB_TK expression CSB_TK
2273                 { $$ = build_array_ref ($2.location, $1, $3); }
2274 |       name OSB_TK error
2275                 {
2276                   yyerror ("Missing term and ']' expected");
2277                   DRECOVER(array_access);
2278                 }
2279 |       name OSB_TK expression error
2280                 {
2281                   yyerror ("']' expected");
2282                   DRECOVER(array_access);
2283                 }
2284 |       primary_no_new_array OSB_TK error
2285                 {
2286                   yyerror ("Missing term and ']' expected");
2287                   DRECOVER(array_access);
2288                 }
2289 |       primary_no_new_array OSB_TK expression error
2290                 {
2291                   yyerror ("']' expected");
2292                   DRECOVER(array_access);
2293                 }
2294 ;
2295
2296 postfix_expression:
2297         primary
2298 |       name
2299 |       post_increment_expression
2300 |       post_decrement_expression
2301 ;
2302
2303 post_increment_expression:
2304         postfix_expression INCR_TK
2305                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2306 ;
2307
2308 post_decrement_expression:
2309         postfix_expression DECR_TK
2310                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2311 ;
2312
2313 trap_overflow_corner_case:
2314         pre_increment_expression
2315 |       pre_decrement_expression
2316 |       PLUS_TK unary_expression
2317                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2318 |       unary_expression_not_plus_minus
2319 |       PLUS_TK error
2320                 {yyerror ("Missing term"); RECOVER}
2321 ;
2322
2323 unary_expression:
2324         trap_overflow_corner_case
2325                 {
2326                   error_if_numeric_overflow ($1);
2327                   $$ = $1;
2328                 }
2329 |       MINUS_TK trap_overflow_corner_case
2330                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2331 |       MINUS_TK error
2332                 {yyerror ("Missing term"); RECOVER}
2333 ;
2334
2335 pre_increment_expression:
2336         INCR_TK unary_expression
2337                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2338 |       INCR_TK error
2339                 {yyerror ("Missing term"); RECOVER}
2340 ;
2341
2342 pre_decrement_expression:
2343         DECR_TK unary_expression
2344                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2345 |       DECR_TK error
2346                 {yyerror ("Missing term"); RECOVER}
2347 ;
2348
2349 unary_expression_not_plus_minus:
2350         postfix_expression
2351 |       NOT_TK unary_expression
2352                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2353 |       NEG_TK unary_expression
2354                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2355 |       cast_expression
2356 |       NOT_TK error
2357                 {yyerror ("Missing term"); RECOVER}
2358 |       NEG_TK error
2359                 {yyerror ("Missing term"); RECOVER}
2360 ;
2361
2362 cast_expression:                /* Error handling here is potentially weak */
2363         OP_TK primitive_type dims CP_TK unary_expression
2364                 {
2365                   tree type = $2;
2366                   int osb = pop_current_osb (ctxp);
2367                   while (osb--)
2368                     type = build_java_array_type (type, -1);
2369                   $$ = build_cast ($1.location, type, $5);
2370                 }
2371 |       OP_TK primitive_type CP_TK unary_expression
2372                 { $$ = build_cast ($1.location, $2, $4); }
2373 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2374                 { $$ = build_cast ($1.location, $2, $4); }
2375 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2376                 {
2377                   const char *ptr;
2378                   int osb = pop_current_osb (ctxp);
2379                   obstack_grow (&temporary_obstack,
2380                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2381                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2382                   while (osb--)
2383                     obstack_grow (&temporary_obstack, "[]", 2);
2384                   obstack_1grow (&temporary_obstack, '\0');
2385                   ptr = obstack_finish (&temporary_obstack);
2386                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2387                   $$ = build_cast ($1.location, $2, $5);
2388                 }
2389 |       OP_TK primitive_type OSB_TK error
2390                 {yyerror ("']' expected, invalid type expression");}
2391 |       OP_TK error
2392                 {
2393                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2394                   RECOVER;
2395                 }
2396 |       OP_TK primitive_type dims CP_TK error
2397                 {yyerror ("Missing term"); RECOVER;}
2398 |       OP_TK primitive_type CP_TK error
2399                 {yyerror ("Missing term"); RECOVER;}
2400 |       OP_TK name dims CP_TK error
2401                 {yyerror ("Missing term"); RECOVER;}
2402 ;
2403
2404 multiplicative_expression:
2405         unary_expression
2406 |       multiplicative_expression MULT_TK unary_expression
2407                 {
2408                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2409                                     $2.location, $1, $3);
2410                 }
2411 |       multiplicative_expression DIV_TK unary_expression
2412                 {
2413                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2414                                     $1, $3);
2415                 }
2416 |       multiplicative_expression REM_TK unary_expression
2417                 {
2418                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2419                                     $1, $3);
2420                 }
2421 |       multiplicative_expression MULT_TK error
2422                 {yyerror ("Missing term"); RECOVER;}
2423 |       multiplicative_expression DIV_TK error
2424                 {yyerror ("Missing term"); RECOVER;}
2425 |       multiplicative_expression REM_TK error
2426                 {yyerror ("Missing term"); RECOVER;}
2427 ;
2428
2429 additive_expression:
2430         multiplicative_expression
2431 |       additive_expression PLUS_TK multiplicative_expression
2432                 {
2433                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2434                                     $1, $3);
2435                 }
2436 |       additive_expression MINUS_TK multiplicative_expression
2437                 {
2438                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2439                                     $1, $3);
2440                 }
2441 |       additive_expression PLUS_TK error
2442                 {yyerror ("Missing term"); RECOVER;}
2443 |       additive_expression MINUS_TK error
2444                 {yyerror ("Missing term"); RECOVER;}
2445 ;
2446
2447 shift_expression:
2448         additive_expression
2449 |       shift_expression LS_TK additive_expression
2450                 {
2451                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2452                                     $1, $3);
2453                 }
2454 |       shift_expression SRS_TK additive_expression
2455                 {
2456                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2457                                     $1, $3);
2458                 }
2459 |       shift_expression ZRS_TK additive_expression
2460                 {
2461                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2462                                     $1, $3);
2463                 }
2464 |       shift_expression LS_TK error
2465                 {yyerror ("Missing term"); RECOVER;}
2466 |       shift_expression SRS_TK error
2467                 {yyerror ("Missing term"); RECOVER;}
2468 |       shift_expression ZRS_TK error
2469                 {yyerror ("Missing term"); RECOVER;}
2470 ;
2471
2472 relational_expression:
2473         shift_expression
2474 |       relational_expression LT_TK shift_expression
2475                 {
2476                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2477                                     $1, $3);
2478                 }
2479 |       relational_expression GT_TK shift_expression
2480                 {
2481                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2482                                     $1, $3);
2483                 }
2484 |       relational_expression LTE_TK shift_expression
2485                 {
2486                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2487                                     $1, $3);
2488                 }
2489 |       relational_expression GTE_TK shift_expression
2490                 {
2491                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2492                                     $1, $3);
2493                 }
2494 |       relational_expression INSTANCEOF_TK reference_type
2495                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2496 |       relational_expression LT_TK error
2497                 {yyerror ("Missing term"); RECOVER;}
2498 |       relational_expression GT_TK error
2499                 {yyerror ("Missing term"); RECOVER;}
2500 |       relational_expression LTE_TK error
2501                 {yyerror ("Missing term"); RECOVER;}
2502 |       relational_expression GTE_TK error
2503                 {yyerror ("Missing term"); RECOVER;}
2504 |       relational_expression INSTANCEOF_TK error
2505                 {yyerror ("Invalid reference type"); RECOVER;}
2506 ;
2507
2508 equality_expression:
2509         relational_expression
2510 |       equality_expression EQ_TK relational_expression
2511                 {
2512                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2513                                     $1, $3);
2514                 }
2515 |       equality_expression NEQ_TK relational_expression
2516                 {
2517                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2518                                     $1, $3);
2519                 }
2520 |       equality_expression EQ_TK error
2521                 {yyerror ("Missing term"); RECOVER;}
2522 |       equality_expression NEQ_TK error
2523                 {yyerror ("Missing term"); RECOVER;}
2524 ;
2525
2526 and_expression:
2527         equality_expression
2528 |       and_expression AND_TK equality_expression
2529                 {
2530                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2531                                     $1, $3);
2532                 }
2533 |       and_expression AND_TK error
2534                 {yyerror ("Missing term"); RECOVER;}
2535 ;
2536
2537 exclusive_or_expression:
2538         and_expression
2539 |       exclusive_or_expression XOR_TK and_expression
2540                 {
2541                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2542                                     $1, $3);
2543                 }
2544 |       exclusive_or_expression XOR_TK error
2545                 {yyerror ("Missing term"); RECOVER;}
2546 ;
2547
2548 inclusive_or_expression:
2549         exclusive_or_expression
2550 |       inclusive_or_expression OR_TK exclusive_or_expression
2551                 {
2552                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2553                                     $1, $3);
2554                 }
2555 |       inclusive_or_expression OR_TK error
2556                 {yyerror ("Missing term"); RECOVER;}
2557 ;
2558
2559 conditional_and_expression:
2560         inclusive_or_expression
2561 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2562                 {
2563                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2564                                     $1, $3);
2565                 }
2566 |       conditional_and_expression BOOL_AND_TK error
2567                 {yyerror ("Missing term"); RECOVER;}
2568 ;
2569
2570 conditional_or_expression:
2571         conditional_and_expression
2572 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2573                 {
2574                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2575                                     $1, $3);
2576                 }
2577 |       conditional_or_expression BOOL_OR_TK error
2578                 {yyerror ("Missing term"); RECOVER;}
2579 ;
2580
2581 conditional_expression:         /* Error handling here is weak */
2582         conditional_or_expression
2583 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2584                 {
2585                   $$ = build3 (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2586                   EXPR_WFL_LINECOL ($$) = $2.location;
2587                 }
2588 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2589                 {
2590                   YYERROR_NOW;
2591                   yyerror ("Missing term");
2592                   DRECOVER (1);
2593                 }
2594 |       conditional_or_expression REL_QM_TK error
2595                 {yyerror ("Missing term"); DRECOVER (2);}
2596 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2597                 {yyerror ("Missing term"); DRECOVER (3);}
2598 ;
2599
2600 assignment_expression:
2601         conditional_expression
2602 |       assignment
2603 ;
2604
2605 assignment:
2606         left_hand_side assignment_operator assignment_expression
2607                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2608 |       left_hand_side assignment_operator error
2609                 {
2610                   YYNOT_TWICE yyerror ("Missing term");
2611                   DRECOVER (assign);
2612                 }
2613 ;
2614
2615 left_hand_side:
2616         name
2617 |       field_access
2618 |       array_access
2619 ;
2620
2621 assignment_operator:
2622         ASSIGN_ANY_TK
2623 |       ASSIGN_TK
2624 ;
2625
2626 expression:
2627         assignment_expression
2628 ;
2629
2630 constant_expression:
2631         expression
2632 ;
2633
2634 %%
2635
2636 /* Helper function to retrieve an OSB count. Should be used when the
2637    `dims:' rule is being used.  */
2638
2639 static int
2640 pop_current_osb (struct parser_ctxt *ctxp)
2641 {
2642   int to_return;
2643
2644   if (ctxp->osb_depth < 0)
2645     abort ();
2646
2647   to_return = CURRENT_OSB (ctxp);
2648   ctxp->osb_depth--;
2649
2650   return to_return;
2651 }
2652
2653 \f
2654
2655 /* This section of the code deal with save/restoring parser contexts.
2656    Add mode documentation here. FIXME */
2657
2658 /* Helper function. Create a new parser context. With
2659    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2660    context is copied, otherwise, the new context is zeroed. The newly
2661    created context becomes the current one.  */
2662
2663 static void
2664 create_new_parser_context (int copy_from_previous)
2665 {
2666   struct parser_ctxt *new;
2667
2668   new = ggc_alloc (sizeof (struct parser_ctxt));
2669   if (copy_from_previous)
2670     {
2671       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2672       /* This flag, indicating the context saves global values,
2673          should only be set by java_parser_context_save_global.  */
2674       new->saved_data_ctx = 0;
2675     }
2676   else
2677     memset (new, 0, sizeof (struct parser_ctxt));
2678
2679   new->next = ctxp;
2680   ctxp = new;
2681 }
2682
2683 /* Create a new parser context and make it the current one. */
2684
2685 void
2686 java_push_parser_context (void)
2687 {
2688   create_new_parser_context (0);
2689 }
2690
2691 void
2692 java_pop_parser_context (int generate)
2693 {
2694   tree current;
2695   struct parser_ctxt *toFree, *next;
2696
2697   if (!ctxp)
2698     return;
2699
2700   toFree = ctxp;
2701   next = ctxp->next;
2702   if (next)
2703     {
2704       input_line = ctxp->lineno;
2705       current_class = ctxp->class_type;
2706     }
2707
2708   /* If the old and new lexers differ, then free the old one.  */
2709   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2710     java_destroy_lexer (ctxp->lexer);
2711
2712   /* Set the single import class file flag to 0 for the current list
2713      of imported things */
2714   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2715     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2716
2717   /* And restore those of the previous context */
2718   if ((ctxp = next))            /* Assignment is really meant here */
2719     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2720       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2721
2722   /* If we pushed a context to parse a class intended to be generated,
2723      we keep it so we can remember the class. What we could actually
2724      do is to just update a list of class names.  */
2725   if (generate)
2726     {
2727       toFree->next = ctxp_for_generation;
2728       ctxp_for_generation = toFree;
2729     }
2730 }
2731
2732 /* Create a parser context for the use of saving some global
2733    variables.  */
2734
2735 void
2736 java_parser_context_save_global (void)
2737 {
2738   if (!ctxp)
2739     {
2740       java_push_parser_context ();
2741       ctxp->saved_data_ctx = 1;
2742     }
2743
2744   /* If this context already stores data, create a new one suitable
2745      for data storage. */
2746   else if (ctxp->saved_data)
2747     {
2748       create_new_parser_context (1);
2749       ctxp->saved_data_ctx = 1;
2750     }
2751
2752   ctxp->lineno = input_line;
2753   ctxp->class_type = current_class;
2754   ctxp->filename = input_filename;
2755   ctxp->function_decl = current_function_decl;
2756   ctxp->saved_data = 1;
2757 }
2758
2759 /* Restore some global variables from the previous context. Make the
2760    previous context the current one.  */
2761
2762 void
2763 java_parser_context_restore_global (void)
2764 {
2765   input_line = ctxp->lineno;
2766   current_class = ctxp->class_type;
2767   input_filename = ctxp->filename;
2768   if (wfl_operator)
2769     EXPR_WFL_FILENAME_NODE (wfl_operator) = get_identifier (input_filename);
2770   current_function_decl = ctxp->function_decl;
2771   ctxp->saved_data = 0;
2772   if (ctxp->saved_data_ctx)
2773     java_pop_parser_context (0);
2774 }
2775
2776 /* Suspend vital data for the current class/function being parsed so
2777    that an other class can be parsed. Used to let local/anonymous
2778    classes be parsed.  */
2779
2780 static void
2781 java_parser_context_suspend (void)
2782 {
2783   /* This makes debugging through java_debug_context easier */
2784   static const char *const name = "<inner buffer context>";
2785
2786   /* Duplicate the previous context, use it to save the globals we're
2787      interested in */
2788   create_new_parser_context (1);
2789   ctxp->function_decl = current_function_decl;
2790   ctxp->class_type = current_class;
2791
2792   /* Then create a new context which inherits all data from the
2793      previous one. This will be the new current context  */
2794   create_new_parser_context (1);
2795
2796   /* Help debugging */
2797   ctxp->next->filename = name;
2798 }
2799
2800 /* Resume vital data for the current class/function being parsed so
2801    that an other class can be parsed. Used to let local/anonymous
2802    classes be parsed.  The trick is the data storing file position
2803    informations must be restored to their current value, so parsing
2804    can resume as if no context was ever saved. */
2805
2806 static void
2807 java_parser_context_resume (void)
2808 {
2809   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2810   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2811   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2812
2813   /* We need to inherit the list of classes to complete/generate */
2814   restored->classd_list = old->classd_list;
2815   restored->class_list = old->class_list;
2816
2817   /* Restore the current class and function from the saver */
2818   current_class = saver->class_type;
2819   current_function_decl = saver->function_decl;
2820
2821   /* Retrieve the restored context */
2822   ctxp = restored;
2823
2824   /* Re-installed the data for the parsing to carry on */
2825   memcpy (&ctxp->marker_begining, &old->marker_begining,
2826           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2827 }
2828
2829 /* Add a new anchor node to which all statement(s) initializing static
2830    and non static initialized upon declaration field(s) will be
2831    linked.  */
2832
2833 static void
2834 java_parser_context_push_initialized_field (void)
2835 {
2836   tree node;
2837
2838   node = build_tree_list (NULL_TREE, NULL_TREE);
2839   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2840   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2841
2842   node = build_tree_list (NULL_TREE, NULL_TREE);
2843   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2844   CPC_INITIALIZER_LIST (ctxp) = node;
2845
2846   node = build_tree_list (NULL_TREE, NULL_TREE);
2847   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2848   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2849 }
2850
2851 /* Pop the lists of initialized field. If this lists aren't empty,
2852    remember them so we can use it to create and populate the finit$
2853    or <clinit> functions. */
2854
2855 static void
2856 java_parser_context_pop_initialized_field (void)
2857 {
2858   tree stmts;
2859   tree class_type = TREE_TYPE (GET_CPC ());
2860
2861   if (CPC_INITIALIZER_LIST (ctxp))
2862     {
2863       stmts = CPC_INITIALIZER_STMT (ctxp);
2864       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2865       if (stmts && !java_error_count)
2866         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2867     }
2868
2869   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2870     {
2871       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2872       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2873         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2874       /* Keep initialization in order to enforce 8.5 */
2875       if (stmts && !java_error_count)
2876         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2877     }
2878
2879   /* JDK 1.1 instance initializers */
2880   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2881     {
2882       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2883       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2884         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2885       if (stmts && !java_error_count)
2886         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2887     }
2888 }
2889
2890 static tree
2891 reorder_static_initialized (tree list)
2892 {
2893   /* We have to keep things in order. The alias initializer have to
2894      come first, then the initialized regular field, in reverse to
2895      keep them in lexical order. */
2896   tree marker, previous = NULL_TREE;
2897   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2898     if (TREE_CODE (marker) == TREE_LIST
2899         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2900       break;
2901
2902   /* No static initialized, the list is fine as is */
2903   if (!previous)
2904     list = TREE_CHAIN (marker);
2905
2906   /* No marker? reverse the whole list */
2907   else if (!marker)
2908     list = nreverse (list);
2909
2910   /* Otherwise, reverse what's after the marker and the new reordered
2911      sublist will replace the marker. */
2912   else
2913     {
2914       TREE_CHAIN (previous) = NULL_TREE;
2915       list = nreverse (list);
2916       list = chainon (TREE_CHAIN (marker), list);
2917     }
2918   return list;
2919 }
2920
2921 /* Helper functions to dump the parser context stack.  */
2922
2923 #define TAB_CONTEXT(C) \
2924   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2925
2926 static void
2927 java_debug_context_do (int tab)
2928 {
2929   struct parser_ctxt *copy = ctxp;
2930   while (copy)
2931     {
2932       TAB_CONTEXT (tab);
2933       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2934       TAB_CONTEXT (tab);
2935       fprintf (stderr, "filename: %s\n", copy->filename);
2936       TAB_CONTEXT (tab);
2937       fprintf (stderr, "lineno: %d\n", copy->lineno);
2938       TAB_CONTEXT (tab);
2939       fprintf (stderr, "package: %s\n",
2940                (copy->package ?
2941                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2942       TAB_CONTEXT (tab);
2943       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2944       TAB_CONTEXT (tab);
2945       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2946       copy = copy->next;
2947       tab += 2;
2948     }
2949 }
2950
2951 /* Dump the stacked up parser contexts. Intended to be called from a
2952    debugger.  */
2953
2954 void
2955 java_debug_context (void)
2956 {
2957   java_debug_context_do (0);
2958 }
2959
2960 \f
2961
2962 /* Flag for the error report routine to issue the error the first time
2963    it's called (overriding the default behavior which is to drop the
2964    first invocation and honor the second one, taking advantage of a
2965    richer context.  */
2966 static int force_error = 0;
2967
2968 /* Reporting an constructor invocation error.  */
2969 static void
2970 parse_ctor_invocation_error (void)
2971 {
2972   if (DECL_CONSTRUCTOR_P (current_function_decl))
2973     yyerror ("Constructor invocation must be first thing in a constructor");
2974   else
2975     yyerror ("Only constructors can invoke constructors");
2976 }
2977
2978 /* Reporting JDK1.1 features not implemented.  */
2979
2980 static tree
2981 parse_jdk1_1_error (const char *msg)
2982 {
2983   sorry (": `%s' JDK1.1(TM) feature", msg);
2984   java_error_count++;
2985   return build_java_empty_stmt ();
2986 }
2987
2988 static int do_warning = 0;
2989
2990 void
2991 yyerror (const char *msg)
2992 {
2993   static java_lc elc;
2994   static int  prev_lineno;
2995   static const char *prev_msg;
2996
2997   int save_lineno;
2998   char *remainder, *code_from_source;
2999
3000   if (!force_error && prev_lineno == input_line)
3001     return;
3002
3003   /* Save current error location but report latter, when the context is
3004      richer.  */
3005   if (ctxp->java_error_flag == 0)
3006     {
3007       ctxp->java_error_flag = 1;
3008       elc = ctxp->elc;
3009       /* Do something to use the previous line if we're reaching the
3010          end of the file... */
3011 #ifdef VERBOSE_SKELETON
3012       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3013 #endif
3014       return;
3015     }
3016
3017   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3018   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3019     return;
3020
3021   ctxp->java_error_flag = 0;
3022   if (do_warning)
3023     java_warning_count++;
3024   else
3025     java_error_count++;
3026
3027   if (elc.col == 0 && msg && msg[1] == ';')
3028     {
3029       elc.col  = ctxp->p_line->char_col-1;
3030       elc.line = ctxp->p_line->lineno;
3031     }
3032
3033   save_lineno = input_line;
3034   prev_lineno = input_line = elc.line;
3035   prev_msg = msg;
3036
3037   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3038   obstack_grow0 (&temporary_obstack,
3039                  code_from_source, strlen (code_from_source));
3040   remainder = obstack_finish (&temporary_obstack);
3041   if (do_warning)
3042     warning ("%s.\n%s", msg, remainder);
3043   else
3044     error ("%s.\n%s", msg, remainder);
3045
3046   /* This allow us to cheaply avoid an extra 'Invalid expression
3047      statement' error report when errors have been already reported on
3048      the same line. This occurs when we report an error but don't have
3049      a synchronization point other than ';', which
3050      expression_statement is the only one to take care of.  */
3051   ctxp->prevent_ese = input_line = save_lineno;
3052 }
3053
3054 static void
3055 issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
3056 {
3057   const char *saved, *saved_input_filename;
3058   char buffer [4096];
3059   vsprintf (buffer, msg, ap);
3060   force_error = 1;
3061
3062   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3063   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3064                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3065
3066   /* We have a CL, that's a good reason for using it if it contains data */
3067   saved = ctxp->filename;
3068   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3069     ctxp->filename = EXPR_WFL_FILENAME (cl);
3070   saved_input_filename = input_filename;
3071   input_filename = ctxp->filename;
3072   java_error (NULL);
3073   java_error (buffer);
3074   ctxp->filename = saved;
3075   input_filename = saved_input_filename;
3076   force_error = 0;
3077 }
3078
3079 /* Issue an error message at a current source line CL */
3080
3081 void
3082 parse_error_context (tree cl, const char *msg, ...)
3083 {
3084   va_list ap;
3085   va_start (ap, msg);
3086   issue_warning_error_from_context (cl, msg, ap);
3087   va_end (ap);
3088 }
3089
3090 /* Issue a warning at a current source line CL */
3091
3092 static void
3093 parse_warning_context (tree cl, const char *msg, ...)
3094 {
3095   va_list ap;
3096   va_start (ap, msg);
3097
3098   force_error = do_warning = 1;
3099   issue_warning_error_from_context (cl, msg, ap);
3100   do_warning = force_error = 0;
3101   va_end (ap);
3102 }
3103
3104 static tree
3105 find_expr_with_wfl (tree node)
3106 {
3107   while (node)
3108     {
3109       char code;
3110       tree to_return;
3111
3112       switch (TREE_CODE (node))
3113         {
3114         case BLOCK:
3115           node = BLOCK_EXPR_BODY (node);
3116           continue;
3117
3118         case COMPOUND_EXPR:
3119           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3120           if (to_return)
3121             return to_return;
3122           node = TREE_OPERAND (node, 1);
3123           continue;
3124
3125         case LOOP_EXPR:
3126           node = TREE_OPERAND (node, 0);
3127           continue;
3128
3129         case LABELED_BLOCK_EXPR:
3130           node = TREE_OPERAND (node, 1);
3131           continue;
3132
3133         default:
3134           code = TREE_CODE_CLASS (TREE_CODE (node));
3135           if (((code == '1') || (code == '2') || (code == 'e'))
3136               && EXPR_WFL_LINECOL (node))
3137             return node;
3138           return NULL_TREE;
3139         }
3140     }
3141   return NULL_TREE;
3142 }
3143
3144 /* Issue a missing return statement error. Uses METHOD to figure the
3145    last line of the method the error occurs in.  */
3146
3147 static void
3148 missing_return_error (tree method)
3149 {
3150   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3151   parse_error_context (wfl_operator, "Missing return statement");
3152 }
3153
3154 /* Issue an unreachable statement error. From NODE, find the next
3155    statement to report appropriately.  */
3156 static void
3157 unreachable_stmt_error (tree node)
3158 {
3159   /* Browse node to find the next expression node that has a WFL. Use
3160      the location to report the error */
3161   if (TREE_CODE (node) == COMPOUND_EXPR)
3162     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3163   else
3164     node = find_expr_with_wfl (node);
3165
3166   if (node)
3167     {
3168       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3169       parse_error_context (wfl_operator, "Unreachable statement");
3170     }
3171   else
3172     abort ();
3173 }
3174
3175 static int
3176 not_accessible_field_error (tree wfl, tree decl)
3177 {
3178   parse_error_context
3179     (wfl, "Can't access %s field `%s.%s' from `%s'",
3180      accessibility_string (get_access_flags_from_decl (decl)),
3181      GET_TYPE_NAME (DECL_CONTEXT (decl)),
3182      IDENTIFIER_POINTER (DECL_NAME (decl)),
3183      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3184   return 1;
3185 }
3186
3187 int
3188 java_report_errors (void)
3189 {
3190   if (java_error_count)
3191     fprintf (stderr, "%d error%s",
3192              java_error_count, (java_error_count == 1 ? "" : "s"));
3193   if (java_warning_count)
3194     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3195              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3196   if (java_error_count || java_warning_count)
3197     putc ('\n', stderr);
3198   return java_error_count;
3199 }
3200
3201 static char *
3202 java_accstring_lookup (int flags)
3203 {
3204   static char buffer [80];
3205 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3206
3207   /* Access modifier looked-up first for easier report on forbidden
3208      access. */
3209   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3210   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3211   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3212   if (flags & ACC_STATIC) COPY_RETURN ("static");
3213   if (flags & ACC_FINAL) COPY_RETURN ("final");
3214   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3215   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3216   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3217   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3218   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3219   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3220
3221   buffer [0] = '\0';
3222   return buffer;
3223 #undef COPY_RETURN
3224 }
3225
3226 /* Returns a string denoting the accessibility of a class or a member as
3227    indicated by FLAGS.  We need a separate function from
3228    java_accstring_lookup, as the latter can return spurious "static", etc.
3229    if package-private access is defined (in which case none of the
3230    relevant access control bits in FLAGS is set).  */
3231
3232 static const char *
3233 accessibility_string (int flags)
3234 {
3235   if (flags & ACC_PRIVATE) return "private";
3236   if (flags & ACC_PROTECTED) return "protected";
3237   if (flags & ACC_PUBLIC) return "public";
3238
3239   return "package-private";
3240 }
3241
3242 /* Issuing error messages upon redefinition of classes, interfaces or
3243    variables. */
3244
3245 static void
3246 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3247 {
3248   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3249                        context, IDENTIFIER_POINTER (id),
3250                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3251   /* Here we should point out where its redefined. It's a unicode. FIXME */
3252 }
3253
3254 static void
3255 variable_redefinition_error (tree context, tree name, tree type, int line)
3256 {
3257   const char *type_name;
3258
3259   /* Figure a proper name for type. We might haven't resolved it */
3260   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3261     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3262   else
3263     type_name = lang_printable_name (type, 0);
3264
3265   parse_error_context (context,
3266                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3267                        IDENTIFIER_POINTER (name),
3268                        type_name, IDENTIFIER_POINTER (name), line);
3269 }
3270
3271 /* If ANAME is terminated with `[]', it indicates an array. This
3272    function returns the number of `[]' found and if this number is
3273    greater than zero, it extracts the array type name and places it in
3274    the node pointed to by TRIMMED unless TRIMMED is null.  */
3275
3276 static int
3277 build_type_name_from_array_name (tree aname, tree *trimmed)
3278 {
3279   const char *name = IDENTIFIER_POINTER (aname);
3280   int len = IDENTIFIER_LENGTH (aname);
3281   int array_dims;
3282
3283   STRING_STRIP_BRACKETS (name, len, array_dims);
3284
3285   if (array_dims && trimmed)
3286     *trimmed = get_identifier_with_length (name, len);
3287
3288   return array_dims;
3289 }
3290
3291 static tree
3292 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3293 {
3294   int more_dims = 0;
3295
3296   /* Eventually get more dims */
3297   more_dims = build_type_name_from_array_name (name, &name);
3298
3299   /* If we have, then craft a new type for this variable */
3300   if (more_dims)
3301     {
3302       tree save = type;
3303
3304       /* If we have a pointer, use its type */
3305       if (TREE_CODE (type) == POINTER_TYPE)
3306         type = TREE_TYPE (type);
3307
3308       /* Building the first dimension of a primitive type uses this
3309          function */
3310       if (JPRIMITIVE_TYPE_P (type))
3311         {
3312           type = build_java_array_type (type, -1);
3313           more_dims--;
3314         }
3315       /* Otherwise, if we have a WFL for this type, use it (the type
3316          is already an array on an unresolved type, and we just keep
3317          on adding dimensions) */
3318       else if (type_wfl)
3319         {
3320           type = type_wfl;
3321           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3322                                                         NULL);
3323         }
3324
3325       /* Add all the dimensions */
3326       while (more_dims--)
3327         type = build_unresolved_array_type (type);
3328
3329       /* The type may have been incomplete in the first place */
3330       if (type_wfl)
3331         type = obtain_incomplete_type (type);
3332     }
3333
3334   if (ret_name)
3335     *ret_name = name;
3336   return type;
3337 }
3338
3339 /* Build something that the type identifier resolver will identify as
3340    being an array to an unresolved type. TYPE_WFL is a WFL on a
3341    identifier. */
3342
3343 static tree
3344 build_unresolved_array_type (tree type_or_wfl)
3345 {
3346   const char *ptr;
3347   tree wfl;
3348
3349   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3350      just create a array type */
3351   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3352     return build_java_array_type (type_or_wfl, -1);
3353
3354   obstack_grow (&temporary_obstack,
3355                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3356                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3357   obstack_grow0 (&temporary_obstack, "[]", 2);
3358   ptr = obstack_finish (&temporary_obstack);
3359   wfl = build_expr_wfl (get_identifier (ptr),
3360                         EXPR_WFL_FILENAME (type_or_wfl),
3361                         EXPR_WFL_LINENO (type_or_wfl),
3362                         EXPR_WFL_COLNO (type_or_wfl));
3363   /* Re-install the existing qualifications so that the type can be
3364      resolved properly. */
3365   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3366   return wfl;
3367 }
3368
3369 static void
3370 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3371 {
3372   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3373     parse_error_context (wfl, "Interface `%s' repeated",
3374                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3375 }
3376
3377 /* Bulk of common class/interface checks. Return 1 if an error was
3378    encountered. TAG is 0 for a class, 1 for an interface.  */
3379
3380 static int
3381 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3382                                 tree qualified_name, tree decl, tree cl)
3383 {
3384   tree node;
3385   int sca = 0;                  /* Static class allowed */
3386   int icaf = 0;                 /* Inner class allowed flags */
3387   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3388
3389   if (!quiet_flag)
3390     fprintf (stderr, " %s%s %s",
3391              (CPC_INNER_P () ? "inner" : ""),
3392              (is_interface ? "interface" : "class"),
3393              IDENTIFIER_POINTER (qualified_name));
3394
3395   /* Scope of an interface/class type name:
3396        - Can't be imported by a single type import
3397        - Can't already exists in the package */
3398   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3399       && (node = find_name_in_single_imports (raw_name))
3400       && !CPC_INNER_P ())
3401     {
3402       parse_error_context
3403         (cl, "%s name `%s' clashes with imported type `%s'",
3404          (is_interface ? "Interface" : "Class"),
3405          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3406       return 1;
3407     }
3408   if (decl && CLASS_COMPLETE_P (decl))
3409     {
3410       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3411                                    qualified_name, decl, cl);
3412       return 1;
3413     }
3414
3415   if (check_inner_class_redefinition (raw_name, cl))
3416     return 1;
3417
3418   /* If public, file name should match class/interface name, except
3419      when dealing with an inner class */
3420   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3421     {
3422       const char *f;
3423
3424       for (f = &input_filename [strlen (input_filename)];
3425            f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3426            f--)
3427         ;
3428       if (IS_DIR_SEPARATOR (f[0]))
3429         f++;
3430       if (strncmp (IDENTIFIER_POINTER (raw_name),
3431                    f , IDENTIFIER_LENGTH (raw_name)) ||
3432           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3433         parse_error_context
3434           (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3435                              (is_interface ? "interface" : "class"),
3436                              IDENTIFIER_POINTER (qualified_name),
3437                              IDENTIFIER_POINTER (raw_name));
3438     }
3439
3440   /* Static classes can be declared only in top level classes. Note:
3441      once static, a inner class is a top level class. */
3442   if (flags & ACC_STATIC)
3443     {
3444       /* Catch the specific error of declaring an class inner class
3445          with no toplevel enclosing class. Prevent check_modifiers from
3446          complaining a second time */
3447       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3448         {
3449           parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3450                                IDENTIFIER_POINTER (qualified_name));
3451           sca = ACC_STATIC;
3452         }
3453       /* Else, in the context of a top-level class declaration, let
3454          `check_modifiers' do its job, otherwise, give it a go */
3455       else
3456         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3457     }
3458
3459   /* Inner classes can be declared private or protected
3460      within their enclosing classes. */
3461   if (CPC_INNER_P ())
3462     {
3463       /* A class which is local to a block can't be public, private,
3464          protected or static. But it is created final, so allow this
3465          one. */
3466       if (current_function_decl)
3467         icaf = sca = uaaf = ACC_FINAL;
3468       else
3469         {
3470           check_modifiers_consistency (flags);
3471           icaf = ACC_PROTECTED;
3472           if (! CLASS_INTERFACE (GET_CPC ()))
3473             icaf |= ACC_PRIVATE;
3474         }
3475     }
3476
3477   if (is_interface)
3478     {
3479       if (CPC_INNER_P ())
3480         uaaf = INTERFACE_INNER_MODIFIERS;
3481       else
3482         uaaf = INTERFACE_MODIFIERS;
3483
3484       check_modifiers ("Illegal modifier `%s' for interface declaration",
3485                        flags, uaaf);
3486     }
3487   else
3488     check_modifiers ((current_function_decl ?
3489                       "Illegal modifier `%s' for local class declaration" :
3490                       "Illegal modifier `%s' for class declaration"),
3491                      flags, uaaf|sca|icaf);
3492   return 0;
3493 }
3494
3495 /* Construct a nested class name.  If the final component starts with
3496    a digit, return true.  Otherwise return false.  */
3497 static int
3498 make_nested_class_name (tree cpc_list)
3499 {
3500   tree name;
3501
3502   if (!cpc_list)
3503     return 0;
3504
3505   make_nested_class_name (TREE_CHAIN (cpc_list));
3506
3507   /* Pick the qualified name when dealing with the first upmost
3508      enclosing class */
3509   name = (TREE_CHAIN (cpc_list)
3510           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3511   obstack_grow (&temporary_obstack,
3512                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3513   obstack_1grow (&temporary_obstack, '$');
3514
3515   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3516 }
3517
3518 /* Can't redefine a class already defined in an earlier scope. */
3519
3520 static int
3521 check_inner_class_redefinition (tree raw_name, tree cl)
3522 {
3523   tree scope_list;
3524
3525   for (scope_list = GET_CPC_LIST (); scope_list;
3526        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3527     if (raw_name == GET_CPC_UN_NODE (scope_list))
3528       {
3529         parse_error_context
3530           (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",
3531            IDENTIFIER_POINTER (raw_name));
3532         return 1;
3533       }
3534   return 0;
3535 }
3536
3537 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3538    we remember ENCLOSING and SUPER.  */
3539
3540 static tree
3541 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3542                      tree *super, tree class_type)
3543 {
3544   tree local_enclosing = *enclosing;
3545   tree local_super = NULL_TREE;
3546
3547   while (local_enclosing)
3548     {
3549       tree intermediate, decl;
3550
3551       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3552         local_enclosing;
3553
3554       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3555         return decl;
3556
3557       intermediate = local_enclosing;
3558       /* Explore enclosing contexts. */
3559       while (INNER_CLASS_DECL_P (intermediate))
3560         {
3561           intermediate = DECL_CONTEXT (intermediate);
3562           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3563             return decl;
3564         }
3565
3566       /* Now go to the upper classes, bail out if necessary.  We will
3567          analyze the returned SUPER and act accordingly (see
3568          do_resolve_class).  */
3569       if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3570           || TREE_TYPE (local_enclosing) == void_type_node)
3571         {
3572           parse_error_context (cl, "Qualifier must be a reference");
3573           local_enclosing = NULL_TREE;
3574           break;
3575         }
3576       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3577       if (!local_super || local_super == object_type_node)
3578         break;
3579
3580       if (TREE_CODE (local_super) == POINTER_TYPE)
3581         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3582       else
3583         local_super = TYPE_NAME (local_super);
3584
3585       /* We may not have checked for circular inheritance yet, so do so
3586          here to prevent an infinite loop. */
3587       if (htab_find (circularity_hash, local_super) != NULL)
3588         {
3589           if (!cl)
3590             cl = lookup_cl (local_enclosing);
3591
3592           parse_error_context
3593             (cl, "Cyclic inheritance involving %s",
3594              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3595           local_enclosing = NULL_TREE;
3596         }
3597       else
3598         local_enclosing = local_super;
3599     }
3600
3601   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3602   *super = local_super;
3603   *enclosing = local_enclosing;
3604
3605   return NULL_TREE;
3606 }
3607
3608 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3609    qualified. */
3610
3611 static tree
3612 find_as_inner_class (tree enclosing, tree name, tree cl)
3613 {
3614   tree qual, to_return;
3615   if (!enclosing)
3616     return NULL_TREE;
3617
3618   name = TYPE_NAME (name);
3619
3620   /* First search: within the scope of `enclosing', search for name */
3621   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3622     qual = EXPR_WFL_QUALIFICATION (cl);
3623   else if (cl)
3624     qual = build_tree_list (cl, NULL_TREE);
3625   else
3626     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3627
3628   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3629     return to_return;
3630
3631   /* We're dealing with a qualified name. Try to resolve thing until
3632      we get something that is an enclosing class. */
3633   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3634     {
3635       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3636
3637       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3638            qual = TREE_CHAIN (qual))
3639         {
3640           acc = merge_qualified_name (acc,
3641                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3642           BUILD_PTR_FROM_NAME (ptr, acc);
3643           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3644         }
3645
3646       /* A NULL qual and a decl means that the search ended
3647          successfully?!? We have to do something then. FIXME */
3648
3649       if (decl)
3650         enclosing = decl;
3651       else
3652         qual = EXPR_WFL_QUALIFICATION (cl);
3653     }
3654   /* Otherwise, create a qual for the other part of the resolution. */
3655   else
3656     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3657
3658   return find_as_inner_class_do (qual, enclosing);
3659 }
3660
3661 /* We go inside the list of sub classes and try to find a way
3662    through. */
3663
3664 static tree
3665 find_as_inner_class_do (tree qual, tree enclosing)
3666 {
3667   if (!qual)
3668     return NULL_TREE;
3669
3670   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3671     {
3672       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3673       tree next_enclosing = NULL_TREE;
3674       tree inner_list;
3675
3676       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3677            inner_list; inner_list = TREE_CHAIN (inner_list))
3678         {
3679           if (TREE_VALUE (inner_list) == name_to_match)
3680             {
3681               next_enclosing = TREE_PURPOSE (inner_list);
3682               break;
3683             }
3684         }
3685       enclosing = next_enclosing;
3686     }
3687
3688   return (!qual && enclosing ? enclosing : NULL_TREE);
3689 }
3690
3691 static void
3692 link_nested_class_to_enclosing (void)
3693 {
3694   if (GET_ENCLOSING_CPC ())
3695     {
3696       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3697       DECL_INNER_CLASS_LIST (enclosing) =
3698         tree_cons (GET_CPC (), GET_CPC_UN (),
3699                    DECL_INNER_CLASS_LIST (enclosing));
3700     }
3701 }
3702
3703 static tree
3704 maybe_make_nested_class_name (tree name)
3705 {
3706   tree id = NULL_TREE;
3707
3708   if (CPC_INNER_P ())
3709     {
3710       /* If we're in a function, we must append a number to create the
3711          nested class name.  However, we don't do this if the class we
3712          are constructing is anonymous, because in that case we'll
3713          already have a number as the class name.  */
3714       if (! make_nested_class_name (GET_CPC_LIST ())
3715           && current_function_decl != NULL_TREE
3716           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3717         {
3718           char buf[10];
3719           sprintf (buf, "%d", anonymous_class_counter);
3720           ++anonymous_class_counter;
3721           obstack_grow (&temporary_obstack, buf, strlen (buf));
3722           obstack_1grow (&temporary_obstack, '$');
3723         }
3724       obstack_grow0 (&temporary_obstack,
3725                      IDENTIFIER_POINTER (name),
3726                      IDENTIFIER_LENGTH (name));
3727       id = get_identifier (obstack_finish (&temporary_obstack));
3728       if (ctxp->package)
3729         QUALIFIED_P (id) = 1;
3730     }
3731   return id;
3732 }
3733
3734 /* If DECL is NULL, create and push a new DECL, record the current
3735    line CL and do other maintenance things.  */
3736
3737 static tree
3738 maybe_create_class_interface_decl (tree decl, tree raw_name,
3739                                    tree qualified_name, tree cl)
3740 {
3741   if (!decl)
3742     decl = push_class (make_class (), qualified_name);
3743
3744   /* Take care of the file and line business */
3745   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3746   /* If we're emitting xrefs, store the line/col number information */
3747   if (flag_emit_xref)
3748     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3749   else
3750     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3751   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3752   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3753   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3754     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3755
3756   PUSH_CPC (decl, raw_name);
3757   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3758
3759   /* Link the declaration to the already seen ones */
3760   TREE_CHAIN (decl) = ctxp->class_list;
3761   ctxp->class_list = decl;
3762
3763   /* Create a new nodes in the global lists */
3764   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3765   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3766
3767   /* Install a new dependency list element */
3768   create_jdep_list (ctxp);
3769
3770   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3771                           IDENTIFIER_POINTER (qualified_name)));
3772   return decl;
3773 }
3774
3775 static void
3776 add_superinterfaces (tree decl, tree interface_list)
3777 {
3778   tree node;
3779   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3780      takes care of ensuring that:
3781        - This is an accessible interface type,
3782        - Circularity detection.
3783    parser_add_interface is then called. If present but not defined,
3784    the check operation is delayed until the super interface gets
3785    defined.  */
3786   for (node = interface_list; node; node = TREE_CHAIN (node))
3787     {
3788       tree current = TREE_PURPOSE (node);
3789       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3790       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3791         {
3792           if (!parser_check_super_interface (idecl, decl, current))
3793             parser_add_interface (decl, idecl, current);
3794         }
3795       else
3796         register_incomplete_type (JDEP_INTERFACE,
3797                                   current, decl, NULL_TREE);
3798     }
3799 }
3800
3801 /* Create an interface in pass1 and return its decl. Return the
3802    interface's decl in pass 2.  */
3803
3804 static tree
3805 create_interface (int flags, tree id, tree super)
3806 {
3807   tree raw_name = EXPR_WFL_NODE (id);
3808   tree q_name = parser_qualified_classname (raw_name);
3809   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3810
3811   /* Certain syntax errors are making SUPER be like ID. Avoid this
3812      case. */
3813   if (ctxp->class_err && id == super)
3814     super = NULL;
3815
3816   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3817
3818   /* Basic checks: scope, redefinition, modifiers */
3819   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3820     {
3821       PUSH_ERROR ();
3822       return NULL_TREE;
3823     }
3824
3825   /* Suspend the current parsing context if we're parsing an inner
3826      interface */
3827   if (CPC_INNER_P ())
3828     {
3829       java_parser_context_suspend ();
3830       /* Interface members are public. */
3831       if (CLASS_INTERFACE (GET_CPC ()))
3832         flags |= ACC_PUBLIC;
3833     }
3834
3835   /* Push a new context for (static) initialized upon declaration fields */
3836   java_parser_context_push_initialized_field ();
3837
3838   /* Interface modifiers check
3839        - public/abstract allowed (already done at that point)
3840        - abstract is obsolete (comes first, it's a warning, or should be)
3841        - Can't use twice the same (checked in the modifier rule) */
3842   if ((flags & ACC_ABSTRACT) && flag_redundant)
3843     parse_warning_context
3844       (MODIFIER_WFL (ABSTRACT_TK),
3845        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3846
3847   /* Create a new decl if DECL is NULL, otherwise fix it */
3848   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3849
3850   /* Interfaces are always abstract. */
3851   flags |= ACC_ABSTRACT;
3852
3853   /* Inner interfaces are always static.  */
3854   if (INNER_CLASS_DECL_P (decl))
3855     flags |= ACC_STATIC;
3856
3857   /* Set super info and mark the class a complete */
3858   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3859                   object_type_node, ctxp->interface_number);
3860   ctxp->interface_number = 0;
3861   CLASS_COMPLETE_P (decl) = 1;
3862   add_superinterfaces (decl, super);
3863
3864   /* Eventually sets the @deprecated tag flag */
3865   CHECK_DEPRECATED (decl);
3866
3867   return decl;
3868 }
3869
3870 /* Patch anonymous class CLASS, by either extending or implementing
3871    DEP.  */
3872
3873 static void
3874 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
3875 {
3876   tree class = TREE_TYPE (class_decl);
3877   tree type =  TREE_TYPE (type_decl);
3878   tree binfo = TYPE_BINFO (class);
3879
3880   /* If it's an interface, implement it */
3881   if (CLASS_INTERFACE (type_decl))
3882     {
3883       if (parser_check_super_interface (type_decl, class_decl, wfl))
3884         return;
3885
3886       if (VEC_space (tree, BINFO_BASE_BINFOS (binfo), 1))
3887         {
3888            /* Extend the binfo - by reallocating and copying it. */
3889           tree new_binfo;
3890           tree base_binfo;
3891           int i;
3892
3893           new_binfo = make_tree_binfo ((BINFO_N_BASE_BINFOS (binfo) + 1) * 2);
3894           for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
3895             BINFO_BASE_APPEND (new_binfo, base_binfo);
3896           CLASS_HAS_SUPER_FLAG (new_binfo) = CLASS_HAS_SUPER_FLAG (binfo);
3897           BINFO_VTABLE (new_binfo) = BINFO_VTABLE (binfo);
3898           TYPE_BINFO (class) = new_binfo;
3899         }
3900
3901       /* And add the interface */
3902       parser_add_interface (class_decl, type_decl, wfl);
3903     }
3904   /* Otherwise, it's a type we want to extend */
3905   else
3906     {
3907       if (parser_check_super (type_decl, class_decl, wfl))
3908         return;
3909       BINFO_TYPE (BINFO_BASE_BINFO (binfo, 0)) = type;
3910     }
3911 }
3912
3913 /* Create an anonymous class which extends/implements TYPE_NAME, and return
3914    its decl.  */
3915
3916 static tree
3917 create_anonymous_class (tree type_name)
3918 {
3919   char buffer [80];
3920   tree super = NULL_TREE, itf = NULL_TREE;
3921   tree id, type_decl, class;
3922
3923   /* The unqualified name of the anonymous class. It's just a number. */
3924   sprintf (buffer, "%d", anonymous_class_counter++);
3925   id = build_wfl_node (get_identifier (buffer));
3926   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL (type_name);
3927
3928   /* We know about the type to extend/implement. We go ahead */
3929   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3930     {
3931       /* Create a class which either implements on extends the designated
3932          class. The class bears an inaccessible name. */
3933       if (CLASS_INTERFACE (type_decl))
3934         {
3935           /* It's OK to modify it here. It's been already used and
3936              shouldn't be reused */
3937           ctxp->interface_number = 1;
3938           /* Interfaces should presented as a list of WFLs */
3939           itf = build_tree_list (type_name, NULL_TREE);
3940         }
3941       else
3942         super = type_name;
3943     }
3944
3945   class = create_class (ACC_FINAL, id, super, itf);
3946
3947   /* We didn't know anything about the stuff. We register a dependence. */
3948   if (!type_decl)
3949     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3950
3951   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3952   return class;
3953 }
3954
3955 /* Create a class in pass1 and return its decl. Return class
3956    interface's decl in pass 2.  */
3957
3958 static tree
3959 create_class (int flags, tree id, tree super, tree interfaces)
3960 {
3961   tree raw_name = EXPR_WFL_NODE (id);
3962   tree class_id, decl;
3963   tree super_decl_type;
3964
3965   /* Certain syntax errors are making SUPER be like ID. Avoid this
3966      case. */
3967   if (ctxp->class_err && id == super)
3968     super = NULL;
3969
3970   class_id = parser_qualified_classname (raw_name);
3971   decl = IDENTIFIER_CLASS_VALUE (class_id);
3972   EXPR_WFL_NODE (id) = class_id;
3973
3974   /* Basic check: scope, redefinition, modifiers */
3975   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3976     {
3977       PUSH_ERROR ();
3978       return NULL_TREE;
3979     }
3980
3981   /* Suspend the current parsing context if we're parsing an inner
3982      class or an anonymous class. */
3983   if (CPC_INNER_P ())
3984     {
3985       java_parser_context_suspend ();
3986       /* Interface members are public. */
3987       if (CLASS_INTERFACE (GET_CPC ()))
3988         flags |= ACC_PUBLIC;
3989     }
3990
3991   /* Push a new context for (static) initialized upon declaration fields */
3992   java_parser_context_push_initialized_field ();
3993
3994   /* Class modifier check:
3995        - Allowed modifier (already done at that point)
3996        - abstract AND final forbidden
3997        - Public classes defined in the correct file */
3998   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
3999     parse_error_context
4000       (id, "Class `%s' can't be declared both abstract and final",
4001        IDENTIFIER_POINTER (raw_name));
4002
4003   /* Create a new decl if DECL is NULL, otherwise fix it */
4004   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
4005
4006   /* If SUPER exists, use it, otherwise use Object */
4007   if (super)
4008     {
4009       /* java.lang.Object can't extend anything.  */
4010       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
4011         {
4012           parse_error_context (id, "`java.lang.Object' can't extend anything");
4013           return NULL_TREE;
4014         }
4015
4016       super_decl_type =
4017         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4018     }
4019   else if (TREE_TYPE (decl) != object_type_node)
4020     super_decl_type = object_type_node;
4021   /* We're defining java.lang.Object */
4022   else
4023     super_decl_type = NULL_TREE;
4024
4025   /* A class nested in an interface is implicitly static. */
4026   if (INNER_CLASS_DECL_P (decl)
4027       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4028     {
4029       flags |= ACC_STATIC;
4030     }
4031
4032   /* Set super info and mark the class as complete. */
4033   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4034                   ctxp->interface_number);
4035   ctxp->interface_number = 0;
4036   CLASS_COMPLETE_P (decl) = 1;
4037   add_superinterfaces (decl, interfaces);
4038
4039   /* TYPE_VFIELD' is a compiler-generated field used to point to
4040      virtual function tables.  In gcj, every class has a common base
4041      virtual function table in java.lang.object.  */
4042   TYPE_VFIELD (TREE_TYPE (decl)) = TYPE_VFIELD (object_type_node);
4043
4044   /* Add the private this$<n> field, Replicate final locals still in
4045      scope as private final fields mangled like val$<local_name>.
4046      This does not occur for top level (static) inner classes. */
4047   if (PURE_INNER_CLASS_DECL_P (decl))
4048     add_inner_class_fields (decl, current_function_decl);
4049
4050   /* If doing xref, store the location at which the inherited class
4051      (if any) was seen. */
4052   if (flag_emit_xref && super)
4053     DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4054
4055   /* Eventually sets the @deprecated tag flag */
4056   CHECK_DEPRECATED (decl);
4057
4058   /* Reset the anonymous class counter when declaring non inner classes */
4059   if (!INNER_CLASS_DECL_P (decl))
4060     anonymous_class_counter = 1;
4061
4062   return decl;
4063 }
4064
4065 /* End a class declaration: register the statements used to create
4066    finit$ and <clinit>, pop the current class and resume the prior
4067    parser context if necessary.  */
4068
4069 static void
4070 end_class_declaration (int resume)
4071 {
4072   /* If an error occurred, context weren't pushed and won't need to be
4073      popped by a resume. */
4074   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4075
4076   if (GET_CPC () != error_mark_node)
4077     dump_java_tree (TDI_class, GET_CPC ());
4078
4079   java_parser_context_pop_initialized_field ();
4080   POP_CPC ();
4081   if (resume && no_error_occurred)
4082     java_parser_context_resume ();
4083
4084   /* We're ending a class declaration, this is a good time to reset
4085      the interface cout. Note that might have been already done in
4086      create_interface, but if at that time an inner class was being
4087      dealt with, the interface count was reset in a context created
4088      for the sake of handling inner classes declaration. */
4089   ctxp->interface_number = 0;
4090 }
4091
4092 static void
4093 add_inner_class_fields (tree class_decl, tree fct_decl)
4094 {
4095   tree block, marker, f;
4096
4097   f = add_field (TREE_TYPE (class_decl),
4098                  build_current_thisn (TREE_TYPE (class_decl)),
4099                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4100                  ACC_PRIVATE);
4101   FIELD_THISN (f) = 1;
4102
4103   if (!fct_decl)
4104     return;
4105
4106   for (block = GET_CURRENT_BLOCK (fct_decl);
4107        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4108     {
4109       tree decl;
4110       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4111         {
4112           tree name, pname;
4113           tree wfl, init, list;
4114
4115           /* Avoid non final arguments. */
4116           if (!LOCAL_FINAL_P (decl))
4117             continue;
4118
4119           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4120           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4121           wfl = build_wfl_node (name);
4122           init = build_wfl_node (pname);
4123           /* Build an initialization for the field: it will be
4124              initialized by a parameter added to finit$, bearing a
4125              mangled name of the field itself (param$<n>.) The
4126              parameter is provided to finit$ by the constructor
4127              invoking it (hence the constructor will also feature a
4128              hidden parameter, set to the value of the outer context
4129              local at the time the inner class is created.)
4130
4131              Note: we take into account all possible locals that can
4132              be accessed by the inner class. It's actually not trivial
4133              to minimize these aliases down to the ones really
4134              used. One way to do that would be to expand all regular
4135              methods first, then finit$ to get a picture of what's
4136              used.  It works with the exception that we would have to
4137              go back on all constructor invoked in regular methods to
4138              have their invocation reworked (to include the right amount
4139              of alias initializer parameters.)
4140
4141              The only real way around, I think, is a first pass to
4142              identify locals really used in the inner class. We leave
4143              the flag FIELD_LOCAL_ALIAS_USED around for that future
4144              use.
4145
4146              On the other hand, it only affect local inner classes,
4147              whose constructors (and finit$ call) will be featuring
4148              unnecessary arguments. It's easy for a developer to keep
4149              this number of parameter down by using the `final'
4150              keyword only when necessary. For the time being, we can
4151              issue a warning on unnecessary finals. FIXME */
4152           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4153                                    wfl, init);
4154
4155           /* Register the field. The TREE_LIST holding the part
4156              initialized/initializer will be marked ARG_FINAL_P so
4157              that the created field can be marked
4158              FIELD_LOCAL_ALIAS. */
4159           list = build_tree_list (wfl, init);
4160           ARG_FINAL_P (list) = 1;
4161           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4162         }
4163     }
4164
4165   if (!CPC_INITIALIZER_STMT (ctxp))
4166     return;
4167
4168   /* If we ever registered an alias field, insert and marker to
4169      remember where the list ends. The second part of the list (the one
4170      featuring initialized fields) so it can be later reversed to
4171      enforce 8.5. The marker will be removed during that operation. */
4172   marker = build_tree_list (NULL_TREE, NULL_TREE);
4173   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4174   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4175 }
4176
4177 /* Can't use lookup_field () since we don't want to load the class and
4178    can't set the CLASS_LOADED_P flag */
4179
4180 static tree
4181 find_field (tree class, tree name)
4182 {
4183   tree decl;
4184   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4185     {
4186       if (DECL_NAME (decl) == name)
4187         return decl;
4188     }
4189   return NULL_TREE;
4190 }
4191
4192 /* Wrap around lookup_field that doesn't potentially upset the value
4193    of CLASS */
4194
4195 static tree
4196 lookup_field_wrapper (tree class, tree name)
4197 {
4198   tree type = class;
4199   tree decl = NULL_TREE;
4200   java_parser_context_save_global ();
4201
4202   /* Last chance: if we're within the context of an inner class, we
4203      might be trying to access a local variable defined in an outer
4204      context. We try to look for it now. */
4205   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4206     {
4207       tree new_name;
4208       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4209       decl = lookup_field (&type, new_name);
4210       if (decl && decl != error_mark_node)
4211         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4212     }
4213   if (!decl || decl == error_mark_node)
4214     {
4215       type = class;
4216       decl = lookup_field (&type, name);
4217     }
4218
4219   /* If the field still hasn't been found, try the next enclosing context. */
4220   if (!decl && INNER_CLASS_TYPE_P (class))
4221     {
4222       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4223       decl = lookup_field_wrapper (outer_type, name);
4224     }
4225
4226   java_parser_context_restore_global ();
4227   return decl == error_mark_node ? NULL : decl;
4228 }
4229
4230 /* Find duplicate field within the same class declarations and report
4231    the error. Returns 1 if a duplicated field was found, 0
4232    otherwise.  */
4233
4234 static int
4235 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4236 {
4237   /* This might be modified to work with method decl as well */
4238   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4239   if (decl)
4240     {
4241       char *t1 = xstrdup (purify_type_name
4242                          ((TREE_CODE (new_type) == POINTER_TYPE
4243                            && TREE_TYPE (new_type) == NULL_TREE) ?
4244                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4245                           lang_printable_name (new_type, 1)));
4246       /* The type may not have been completed by the time we report
4247          the error */
4248       char *t2 = xstrdup (purify_type_name
4249                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4250                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4251                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4252                           lang_printable_name (TREE_TYPE (decl), 1)));
4253       parse_error_context
4254         (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4255          t1, IDENTIFIER_POINTER (new_field_name),
4256          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4257          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4258       free (t1);
4259       free (t2);
4260       return 1;
4261     }
4262   return 0;
4263 }
4264
4265 /* Field registration routine. If TYPE doesn't exist, field
4266    declarations are linked to the undefined TYPE dependency list, to
4267    be later resolved in java_complete_class () */
4268
4269 static void
4270 register_fields (int flags, tree type, tree variable_list)
4271 {
4272   tree current, saved_type;
4273   tree class_type = NULL_TREE;
4274   int saved_lineno = input_line;
4275   int must_chain = 0;
4276   tree wfl = NULL_TREE;
4277
4278   if (GET_CPC ())
4279     class_type = TREE_TYPE (GET_CPC ());
4280
4281   if (!class_type || class_type == error_mark_node)
4282     return;
4283
4284   /* If we're adding fields to interfaces, those fields are public,
4285      static, final */
4286   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4287     {
4288       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4289                                  flags, ACC_PUBLIC, "interface field(s)");
4290       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4291                                  flags, ACC_STATIC, "interface field(s)");
4292       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4293                                  flags, ACC_FINAL, "interface field(s)");
4294       check_modifiers ("Illegal interface member modifier `%s'", flags,
4295                        INTERFACE_FIELD_MODIFIERS);
4296       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4297     }
4298
4299   /* Obtain a suitable type for resolution, if necessary */
4300   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4301
4302   /* If TYPE is fully resolved and we don't have a reference, make one */
4303   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4304
4305   for (current = variable_list, saved_type = type; current;
4306        current = TREE_CHAIN (current), type = saved_type)
4307     {
4308       tree real_type;
4309       tree field_decl;
4310       tree cl = TREE_PURPOSE (current);
4311       tree init = TREE_VALUE (current);
4312       tree current_name = EXPR_WFL_NODE (cl);
4313
4314       /* Can't declare non-final static fields in inner classes */
4315       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4316           && !(flags & ACC_FINAL))
4317         parse_error_context
4318           (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4319            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4320            lang_printable_name (class_type, 0));
4321
4322       /* Process NAME, as it may specify extra dimension(s) for it */
4323       type = build_array_from_name (type, wfl, current_name, &current_name);
4324
4325       /* Type adjustment. We may have just readjusted TYPE because
4326          the variable specified more dimensions. Make sure we have
4327          a reference if we can and don't have one already. Also
4328          change the name if we have an init. */
4329       if (type != saved_type)
4330         {
4331           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4332           if (init)
4333             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4334         }
4335
4336       real_type = GET_REAL_TYPE (type);
4337       /* Check for redeclarations */
4338       if (duplicate_declaration_error_p (current_name, real_type, cl))
4339         continue;
4340
4341       /* Set input_line to the line the field was found and create a
4342          declaration for it. Eventually sets the @deprecated tag flag. */
4343       if (flag_emit_xref)
4344         input_line = EXPR_WFL_LINECOL (cl);
4345       else
4346         input_line = EXPR_WFL_LINENO (cl);
4347       field_decl = add_field (class_type, current_name, real_type, flags);
4348       CHECK_DEPRECATED_NO_RESET (field_decl);
4349
4350       /* If the field denotes a final instance variable, then we
4351          allocate a LANG_DECL_SPECIFIC part to keep track of its
4352          initialization. We also mark whether the field was
4353          initialized upon its declaration. We don't do that if the
4354          created field is an alias to a final local. */
4355       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4356         {
4357           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4358           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4359         }
4360
4361       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4362          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4363          hide parameters to this inner class finit$ and
4364          constructors. It also means that the field isn't final per
4365          say. */
4366       if (ARG_FINAL_P (current))
4367         {
4368           FIELD_LOCAL_ALIAS (field_decl) = 1;
4369           FIELD_FINAL (field_decl) = 0;
4370         }
4371
4372       /* Check if we must chain. */
4373       if (must_chain)
4374         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4375
4376       /* If we have an initialization value tied to the field */
4377       if (init)
4378         {
4379           /* The field is declared static */
4380           if (flags & ACC_STATIC)
4381             {
4382               /* We include the field and its initialization part into
4383                  a list used to generate <clinit>. After <clinit> is
4384                  walked, field initializations will be processed and
4385                  fields initialized with known constants will be taken
4386                  out of <clinit> and have their DECL_INITIAL set
4387                  appropriately. */
4388               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4389               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4390               if (TREE_OPERAND (init, 1)
4391                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4392                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4393             }
4394           /* A non-static field declared with an immediate initialization is
4395              to be initialized in <init>, if any.  This field is remembered
4396              to be processed at the time of the generation of <init>. */
4397           else
4398             {
4399               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4400               SET_CPC_INITIALIZER_STMT (ctxp, init);
4401             }
4402           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4403           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4404         }
4405     }
4406
4407   CLEAR_DEPRECATED;
4408   input_line = saved_lineno;
4409 }
4410
4411 /* Generate finit$, using the list of initialized fields to populate
4412    its body. finit$'s parameter(s) list is adjusted to include the
4413    one(s) used to initialized the field(s) caching outer context
4414    local(s).  */
4415
4416 static tree
4417 generate_finit (tree class_type)
4418 {
4419   int count = 0;
4420   tree list = TYPE_FINIT_STMT_LIST (class_type);
4421   tree mdecl, current, parms;
4422
4423   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4424                                                   class_type, NULL_TREE,
4425                                                   &count);
4426   CRAFTED_PARAM_LIST_FIXUP (parms);
4427   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4428                                     finit_identifier_node, parms);
4429   fix_method_argument_names (parms, mdecl);
4430   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4431                        mdecl, NULL_TREE);
4432   DECL_FUNCTION_NAP (mdecl) = count;
4433   start_artificial_method_body (mdecl);
4434
4435   for (current = list; current; current = TREE_CHAIN (current))
4436     java_method_add_stmt (mdecl,
4437                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4438                                                 current));
4439   end_artificial_method_body (mdecl);
4440   return mdecl;
4441 }
4442
4443 /* Generate a function to run the instance initialization code. The
4444    private method is called `instinit$'. Unless we're dealing with an
4445    anonymous class, we determine whether all ctors of CLASS_TYPE
4446    declare a checked exception in their `throws' clause in order to
4447    see whether it's necessary to encapsulate the instance initializer
4448    statements in a try/catch/rethrow sequence.  */
4449
4450 static tree
4451 generate_instinit (tree class_type)
4452 {
4453   tree current;
4454   tree compound = NULL_TREE;
4455   tree parms = tree_cons (this_identifier_node,
4456                           build_pointer_type (class_type), end_params_node);
4457   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4458                                          void_type_node,
4459                                          instinit_identifier_node, parms);
4460
4461   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4462                        mdecl, NULL_TREE);
4463
4464   /* Gather all the statements in a compound */
4465   for (current = TYPE_II_STMT_LIST (class_type);
4466        current; current = TREE_CHAIN (current))
4467     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4468
4469   /* We need to encapsulate COMPOUND by a try/catch statement to
4470      rethrow exceptions that might occur in the instance initializer.
4471      We do that only if all ctors of CLASS_TYPE are set to catch a
4472      checked exception. This doesn't apply to anonymous classes (since
4473      they don't have declared ctors.) */
4474   if (!ANONYMOUS_CLASS_P (class_type) &&
4475       ctors_unchecked_throws_clause_p (class_type))
4476     {
4477       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4478                                              build1 (THROW_EXPR, NULL_TREE,
4479                                                      build_wfl_node (wpv_id)));
4480       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4481                                                       exception_type_node);
4482     }
4483
4484   start_artificial_method_body (mdecl);
4485   java_method_add_stmt (mdecl, compound);
4486   end_artificial_method_body (mdecl);
4487
4488   return mdecl;
4489 }
4490
4491 /* FIXME */
4492 static tree
4493 build_instinit_invocation (tree class_type)
4494 {
4495   tree to_return = NULL_TREE;
4496
4497   if (TYPE_II_STMT_LIST (class_type))
4498     {
4499       tree parm = build_tree_list (NULL_TREE,
4500                                    build_wfl_node (this_identifier_node));
4501       to_return =
4502         build_method_invocation (build_wfl_node (instinit_identifier_node),
4503                                  parm);
4504     }
4505   return to_return;
4506 }
4507
4508 /* Shared across method_declarator and method_header to remember the
4509    patch stage that was reached during the declaration of the method.
4510    A method DECL is built differently is there is no patch
4511    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4512    pending on the currently defined method.  */
4513
4514 static int patch_stage;
4515
4516 /* Check the method declaration and add the method to its current
4517    class.  If the argument list is known to contain incomplete types,
4518    the method is partially added and the registration will be resume
4519    once the method arguments resolved. If TYPE is NULL, we're dealing
4520    with a constructor.  */
4521
4522 static tree
4523 method_header (int flags, tree type, tree mdecl, tree throws)
4524 {
4525   tree type_wfl = NULL_TREE;
4526   tree meth_name = NULL_TREE;
4527   tree current, orig_arg, this_class = NULL;
4528   tree id, meth;
4529   int saved_lineno;
4530   int constructor_ok = 0, must_chain;
4531   int count;
4532
4533   if (mdecl == error_mark_node)
4534     return error_mark_node;
4535   meth = TREE_VALUE (mdecl);
4536   id = TREE_PURPOSE (mdecl);
4537
4538   check_modifiers_consistency (flags);
4539
4540   if (GET_CPC ())
4541     this_class = TREE_TYPE (GET_CPC ());
4542
4543   if (!this_class || this_class == error_mark_node)
4544     return NULL_TREE;
4545
4546   /* There are some forbidden modifiers for an abstract method and its
4547      class must be abstract as well.  */
4548   if (type && (flags & ACC_ABSTRACT))
4549     {
4550       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4551       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4552       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4553       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4554       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4555       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4556       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4557           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4558         parse_error_context
4559           (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4560            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4561            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4562     }
4563
4564   /* A native method can't be strictfp.  */
4565   if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4566     parse_error_context (id, "native method `%s' can't be strictfp",
4567                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4568   /* No such thing as a transient or volatile method.  */
4569   if ((flags & ACC_TRANSIENT))
4570     parse_error_context (id, "method `%s' can't be transient",
4571                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4572   if ((flags & ACC_VOLATILE))
4573     parse_error_context (id, "method `%s' can't be volatile",
4574                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4575
4576   /* Things to be checked when declaring a constructor */
4577   if (!type)
4578     {
4579       int ec = java_error_count;
4580       /* 8.6: Constructor declarations: we might be trying to define a
4581          method without specifying a return type. */
4582       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4583         parse_error_context
4584           (id, "Invalid method declaration, return type required");
4585       /* 8.6.3: Constructor modifiers */
4586       else
4587         {
4588           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4589           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4590           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4591           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4592           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4593           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4594         }
4595       /* If we found error here, we don't consider it's OK to tread
4596          the method definition as a constructor, for the rest of this
4597          function */
4598       if (ec == java_error_count)
4599         constructor_ok = 1;
4600     }
4601
4602   /* Method declared within the scope of an interface are implicitly
4603      abstract and public. Conflicts with other erroneously provided
4604      modifiers are checked right after. */
4605
4606   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4607     {
4608       /* If FLAGS isn't set because of a modifier, turn the
4609          corresponding modifier WFL to NULL so we issue a warning on
4610          the obsolete use of the modifier */
4611       if (!(flags & ACC_PUBLIC))
4612         MODIFIER_WFL (PUBLIC_TK) = NULL;
4613       if (!(flags & ACC_ABSTRACT))
4614         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4615       flags |= ACC_PUBLIC;
4616       flags |= ACC_ABSTRACT;
4617     }
4618
4619   /* Inner class can't declare static methods */
4620   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4621     {
4622       parse_error_context
4623         (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4624          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4625          lang_printable_name (this_class, 0));
4626     }
4627
4628   /* Modifiers context reset moved up, so abstract method declaration
4629      modifiers can be later checked.  */
4630
4631   /* Set constructor returned type to void and method name to <init>,
4632      unless we found an error identifier the constructor (in which
4633      case we retain the original name) */
4634   if (!type)
4635     {
4636       type = void_type_node;
4637       if (constructor_ok)
4638         meth_name = init_identifier_node;
4639     }
4640   else
4641     meth_name = EXPR_WFL_NODE (id);
4642
4643   /* Do the returned type resolution and registration if necessary */
4644   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4645
4646   if (meth_name)
4647     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4648   EXPR_WFL_NODE (id) = meth_name;
4649   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4650
4651   if (must_chain)
4652     {
4653       patch_stage = JDEP_METHOD_RETURN;
4654       register_incomplete_type (patch_stage, type_wfl, id, type);
4655       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4656     }
4657   else
4658     TREE_TYPE (meth) = type;
4659
4660   saved_lineno = input_line;
4661   /* When defining an abstract or interface method, the curly
4662      bracket at level 1 doesn't exist because there is no function
4663      body */
4664   input_line = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4665             EXPR_WFL_LINENO (id));
4666
4667   /* Remember the original argument list */
4668   orig_arg = TYPE_ARG_TYPES (meth);
4669
4670   if (patch_stage)              /* includes ret type and/or all args */
4671     {
4672       jdep *jdep;
4673       meth = add_method_1 (this_class, flags, meth_name, meth);
4674       /* Patch for the return type */
4675       if (patch_stage == JDEP_METHOD_RETURN)
4676         {
4677           jdep = CLASSD_LAST (ctxp->classd_list);
4678           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4679         }
4680       /* This is the stop JDEP. METH allows the function's signature
4681          to be computed. */
4682       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4683     }
4684   else
4685     meth = add_method (this_class, flags, meth_name,
4686                        build_java_signature (meth));
4687
4688   /* Remember final parameters */
4689   MARK_FINAL_PARMS (meth, orig_arg);
4690
4691   /* Fix the method argument list so we have the argument name
4692      information */
4693   fix_method_argument_names (orig_arg, meth);
4694
4695   /* Register the parameter number and re-install the current line
4696      number */
4697   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4698   input_line = saved_lineno;
4699
4700   /* Register exception specified by the `throws' keyword for
4701      resolution and set the method decl appropriate field to the list.
4702      Note: the grammar ensures that what we get here are class
4703      types. */
4704   if (throws)
4705     {
4706       throws = nreverse (throws);
4707       for (current = throws; current; current = TREE_CHAIN (current))
4708         {
4709           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4710                                     NULL_TREE, NULL_TREE);
4711           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4712             &TREE_VALUE (current);
4713         }
4714       DECL_FUNCTION_THROWS (meth) = throws;
4715     }
4716
4717   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4718     DECL_FUNCTION_WFL (meth) = id;
4719
4720   /* Set the flag if we correctly processed a constructor */
4721   if (constructor_ok)
4722     {
4723       DECL_CONSTRUCTOR_P (meth) = 1;
4724       /* Compute and store the number of artificial parameters declared
4725          for this constructor */
4726       for (count = 0, current = TYPE_FIELDS (this_class); current;
4727            current = TREE_CHAIN (current))
4728         if (FIELD_LOCAL_ALIAS (current))
4729           count++;
4730       DECL_FUNCTION_NAP (meth) = count;
4731     }
4732
4733   /* Eventually set the @deprecated tag flag */
4734   CHECK_DEPRECATED (meth);
4735
4736   /* If doing xref, store column and line number information instead
4737      of the line number only. */
4738   if (flag_emit_xref)
4739     DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4740
4741   return meth;
4742 }
4743
4744 static void
4745 fix_method_argument_names (tree orig_arg, tree meth)
4746 {
4747   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4748   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4749     {
4750       TREE_PURPOSE (arg) = this_identifier_node;
4751       arg = TREE_CHAIN (arg);
4752     }
4753   while (orig_arg != end_params_node)
4754     {
4755       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4756       orig_arg = TREE_CHAIN (orig_arg);
4757       arg = TREE_CHAIN (arg);
4758     }
4759 }
4760
4761 /* Complete the method declaration with METHOD_BODY.  */
4762
4763 static void
4764 finish_method_declaration (tree method_body)
4765 {
4766   int flags;
4767
4768   if (!current_function_decl)
4769     return;
4770
4771   flags = get_access_flags_from_decl (current_function_decl);
4772
4773   /* 8.4.5 Method Body */
4774   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4775     {
4776       tree name = DECL_NAME (current_function_decl);
4777       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4778                            "%s method `%s' can't have a body defined",
4779                            (METHOD_NATIVE (current_function_decl) ?
4780                             "Native" : "Abstract"),
4781                            IDENTIFIER_POINTER (name));
4782       method_body = NULL_TREE;
4783     }
4784   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4785     {
4786       tree name = DECL_NAME (current_function_decl);
4787       parse_error_context
4788         (DECL_FUNCTION_WFL (current_function_decl),
4789          "Non native and non abstract method `%s' must have a body defined",
4790          IDENTIFIER_POINTER (name));
4791       method_body = NULL_TREE;
4792     }
4793
4794   if (flag_emit_class_files && method_body
4795       && TREE_CODE (method_body) == NOP_EXPR
4796       && TREE_TYPE (current_function_decl)
4797       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4798     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4799
4800   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4801   maybe_absorb_scoping_blocks ();
4802   /* Exit function's body */
4803   exit_block ();
4804   /* Merge last line of the function with first line, directly in the
4805      function decl. It will be used to emit correct debug info. */
4806   if (!flag_emit_xref)
4807     DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4808
4809   /* Since function's argument's list are shared, reset the
4810      ARG_FINAL_P parameter that might have been set on some of this
4811      function parameters. */
4812   UNMARK_FINAL_PARMS (current_function_decl);
4813
4814   /* So we don't have an irrelevant function declaration context for
4815      the next static block we'll see. */
4816   current_function_decl = NULL_TREE;
4817 }
4818
4819 /* Build a an error message for constructor circularity errors.  */
4820
4821 static char *
4822 constructor_circularity_msg (tree from, tree to)
4823 {
4824   static char string [4096];
4825   char *t = xstrdup (lang_printable_name (from, 0));
4826   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4827   free (t);
4828   return string;
4829 }
4830
4831 /* Verify a circular call to METH. Return 1 if an error is found, 0
4832    otherwise.  */
4833
4834 static GTY(()) tree vcc_list;
4835 static int
4836 verify_constructor_circularity (tree meth, tree current)
4837 {
4838   tree c;
4839
4840   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4841     {
4842       if (TREE_VALUE (c) == meth)
4843         {
4844           char *t;
4845           if (vcc_list)
4846             {
4847               tree liste;
4848               vcc_list = nreverse (vcc_list);
4849               for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4850                 {
4851                   parse_error_context
4852                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4853                      constructor_circularity_msg
4854                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4855                   java_error_count--;
4856                 }
4857             }
4858           t = xstrdup (lang_printable_name (meth, 0));
4859           parse_error_context (TREE_PURPOSE (c),
4860                                "%s: recursive invocation of constructor `%s'",
4861                                constructor_circularity_msg (current, meth), t);
4862           free (t);
4863           vcc_list = NULL_TREE;
4864           return 1;
4865         }
4866     }
4867   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4868     {
4869       vcc_list = tree_cons (c, current, vcc_list);
4870       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4871         return 1;
4872       vcc_list = TREE_CHAIN (vcc_list);
4873     }
4874   return 0;
4875 }
4876
4877 /* Check modifiers that can be declared but exclusively */
4878
4879 static void
4880 check_modifiers_consistency (int flags)
4881 {
4882   int acc_count = 0;
4883   tree cl = NULL_TREE;
4884
4885   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4886   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4887   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4888   if (acc_count > 1)
4889     parse_error_context
4890       (cl, "Inconsistent member declaration.  At most one of `public', `private', or `protected' may be specified");
4891
4892   acc_count = 0;
4893   cl = NULL_TREE;
4894   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4895   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4896   if (acc_count > 1)
4897     parse_error_context (cl,
4898                          "Inconsistent member declaration.  At most one of `final' or `volatile' may be specified");
4899 }
4900
4901 /* Check the methode header METH for abstract specifics features */
4902
4903 static void
4904 check_abstract_method_header (tree meth)
4905 {
4906   int flags = get_access_flags_from_decl (meth);
4907
4908   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4909                               ACC_ABSTRACT, "abstract method",
4910                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4911   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4912                               ACC_PUBLIC, "abstract method",
4913                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4914
4915   check_modifiers ("Illegal modifier `%s' for interface method",
4916                   flags, INTERFACE_METHOD_MODIFIERS);
4917 }
4918
4919 /* Create a FUNCTION_TYPE node and start augmenting it with the
4920    declared function arguments. Arguments type that can't be resolved
4921    are left as they are, but the returned node is marked as containing
4922    incomplete types.  */
4923
4924 static tree
4925 method_declarator (tree id, tree list)
4926 {
4927   tree arg_types = NULL_TREE, current, node;
4928   tree meth = make_node (FUNCTION_TYPE);
4929   jdep *jdep;
4930
4931   patch_stage = JDEP_NO_PATCH;
4932
4933   if (GET_CPC () == error_mark_node)
4934     return error_mark_node;
4935
4936   /* If we're dealing with an inner class constructor, we hide the
4937      this$<n> decl in the name field of its parameter declaration.  We
4938      also might have to hide the outer context local alias
4939      initializers. Not done when the class is a toplevel class. */
4940   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4941       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4942     {
4943       tree aliases_list, type, thisn;
4944       /* First the aliases, linked to the regular parameters */
4945       aliases_list =
4946         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4947                                                 TREE_TYPE (GET_CPC ()),
4948                                                 NULL_TREE, NULL);
4949       list = chainon (nreverse (aliases_list), list);
4950
4951       /* Then this$<n> */
4952       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4953       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4954       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4955                         list);
4956     }
4957
4958   for (current = list; current; current = TREE_CHAIN (current))
4959     {
4960       int must_chain = 0;
4961       tree wfl_name = TREE_PURPOSE (current);
4962       tree type = TREE_VALUE (current);
4963       tree name = EXPR_WFL_NODE (wfl_name);
4964       tree already, arg_node;
4965       tree type_wfl = NULL_TREE;
4966       tree real_type;
4967
4968       /* Obtain a suitable type for resolution, if necessary */
4969       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4970
4971       /* Process NAME, as it may specify extra dimension(s) for it */
4972       type = build_array_from_name (type, type_wfl, name, &name);
4973       EXPR_WFL_NODE (wfl_name) = name;
4974
4975       real_type = GET_REAL_TYPE (type);
4976       if (TREE_CODE (real_type) == RECORD_TYPE)
4977         {
4978           real_type = promote_type (real_type);
4979           if (TREE_CODE (type) == TREE_LIST)
4980             TREE_PURPOSE (type) = real_type;
4981         }
4982
4983       /* Check redefinition */
4984       for (already = arg_types; already; already = TREE_CHAIN (already))
4985         if (TREE_PURPOSE (already) == name)
4986           {
4987             parse_error_context
4988               (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4989                IDENTIFIER_POINTER (name),
4990                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4991             break;
4992           }
4993
4994       /* If we've an incomplete argument type, we know there is a location
4995          to patch when the type get resolved, later.  */
4996       jdep = NULL;
4997       if (must_chain)
4998         {
4999           patch_stage = JDEP_METHOD;
5000           type = register_incomplete_type (patch_stage,
5001                                            type_wfl, wfl_name, type);
5002           jdep = CLASSD_LAST (ctxp->classd_list);
5003           JDEP_MISC (jdep) = id;
5004         }
5005
5006       /* The argument node: a name and a (possibly) incomplete type.  */
5007       arg_node = build_tree_list (name, real_type);
5008       /* Remember arguments declared final. */
5009       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
5010
5011       if (jdep)
5012         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
5013       TREE_CHAIN (arg_node) = arg_types;
5014       arg_types = arg_node;
5015     }
5016   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
5017   node = build_tree_list (id, meth);
5018   return node;
5019 }
5020
5021 static int
5022 unresolved_type_p (tree wfl, tree *returned)
5023 {
5024   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5025     {
5026       if (returned)
5027         {
5028           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5029           if (decl && current_class && (decl == TYPE_NAME (current_class)))
5030             *returned = TREE_TYPE (decl);
5031           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5032             *returned = TREE_TYPE (GET_CPC ());
5033           else
5034             *returned = NULL_TREE;
5035         }
5036       return 1;
5037     }
5038   if (returned)
5039     *returned = wfl;
5040   return 0;
5041 }
5042
5043 /* From NAME, build a qualified identifier node using the
5044    qualification from the current package definition. */
5045
5046 static tree
5047 parser_qualified_classname (tree name)
5048 {
5049   tree nested_class_name;
5050
5051   if ((nested_class_name = maybe_make_nested_class_name (name)))
5052     return nested_class_name;
5053
5054   if (ctxp->package)
5055     return merge_qualified_name (ctxp->package, name);
5056   else
5057     return name;
5058 }
5059
5060 /* Called once the type a interface extends is resolved. Returns 0 if
5061    everything is OK.  */
5062
5063 static int
5064 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5065 {
5066   tree super_type = TREE_TYPE (super_decl);
5067
5068   /* Has to be an interface */
5069   if (!CLASS_INTERFACE (super_decl))
5070     {
5071       parse_error_context
5072         (this_wfl, "%s `%s' can't implement/extend %s `%s'",
5073          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5074           "Interface" : "Class"),
5075          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5076          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5077          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5078       return 1;
5079     }
5080
5081   /* Check top-level interface access. Inner classes are subject to member
5082      access rules (6.6.1). */
5083   if (! INNER_CLASS_P (super_type)
5084       && check_pkg_class_access (DECL_NAME (super_decl),
5085                                  NULL_TREE, true, this_decl))
5086     return 1;
5087
5088   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5089                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5090                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5091   return 0;
5092 }
5093
5094 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5095    0 if everything is OK.  */
5096
5097 static int
5098 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5099 {
5100   tree super_type = TREE_TYPE (super_decl);
5101
5102   /* SUPER should be a CLASS (neither an array nor an interface) */
5103   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5104     {
5105       parse_error_context
5106         (wfl, "Class `%s' can't subclass %s `%s'",
5107          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5108          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5109          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5110       return 1;
5111     }
5112
5113   if (CLASS_FINAL (TYPE_NAME (super_type)))
5114     {
5115       parse_error_context (wfl, "Can't subclass final classes: %s",
5116                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5117       return 1;
5118     }
5119
5120   /* Check top-level class scope. Inner classes are subject to member access
5121      rules (6.6.1). */
5122   if (! INNER_CLASS_P (super_type)
5123       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true, NULL_TREE)))
5124     return 1;
5125
5126   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5127                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5128                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5129   return 0;
5130 }
5131
5132 /* Create a new dependency list and link it (in a LIFO manner) to the
5133    CTXP list of type dependency list.  */
5134
5135 static void
5136 create_jdep_list (struct parser_ctxt *ctxp)
5137 {
5138   jdeplist *new = xmalloc (sizeof (jdeplist));
5139   new->first = new->last = NULL;
5140   new->next = ctxp->classd_list;
5141   ctxp->classd_list = new;
5142 }
5143
5144 static jdeplist *
5145 reverse_jdep_list (struct parser_ctxt *ctxp)
5146 {
5147   jdeplist *prev = NULL, *current, *next;
5148   for (current = ctxp->classd_list; current; current = next)
5149     {
5150       next = current->next;
5151       current->next = prev;
5152       prev = current;
5153     }
5154   return prev;
5155 }
5156
5157 /* Create a fake pointer based on the ID stored in
5158    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5159    registered again. */
5160
5161 static tree
5162 obtain_incomplete_type (tree type_name)
5163 {
5164   tree ptr = NULL_TREE, name;
5165
5166   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5167     name = EXPR_WFL_NODE (type_name);
5168   else if (INCOMPLETE_TYPE_P (type_name))
5169     name = TYPE_NAME (type_name);
5170   else
5171     abort ();
5172
5173   /* Workaround from build_pointer_type for incomplete types.  */
5174   BUILD_PTR_FROM_NAME (ptr, name);
5175   TYPE_MODE (ptr) = ptr_mode;
5176   layout_type (ptr);
5177
5178   return ptr;
5179 }
5180
5181 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5182    non NULL instead of computing a new fake type based on WFL. The new
5183    dependency is inserted in the current type dependency list, in FIFO
5184    manner.  */
5185
5186 static tree
5187 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5188 {
5189   jdep *new = xmalloc (sizeof (jdep));
5190
5191   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5192     ptr = obtain_incomplete_type (wfl);
5193
5194   JDEP_KIND (new) = kind;
5195   JDEP_DECL (new) = decl;
5196   JDEP_TO_RESOLVE (new) = ptr;
5197   JDEP_WFL (new) = wfl;
5198   JDEP_CHAIN (new) = NULL;
5199   JDEP_MISC (new) = NULL_TREE;
5200   /* For some dependencies, set the enclosing class of the current
5201      class to be the enclosing context */
5202   if ((kind == JDEP_INTERFACE || kind == JDEP_ANONYMOUS || kind == JDEP_SUPER)
5203       && GET_ENCLOSING_CPC ())
5204     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5205   else
5206     JDEP_ENCLOSING (new) = GET_CPC ();
5207   JDEP_GET_PATCH (new) = (tree *)NULL;
5208
5209   JDEP_INSERT (ctxp->classd_list, new);
5210
5211   return ptr;
5212 }
5213
5214 /* This checks for circular references with innerclasses. We start
5215    from SOURCE and should never reach TARGET. Extended/implemented
5216    types in SOURCE have their enclosing context checked not to reach
5217    TARGET. When the last enclosing context of SOURCE is reached, its
5218    extended/implemented types are also checked not to reach TARGET.
5219    In case of error, WFL of the offending type is returned; NULL_TREE
5220    otherwise.  */
5221
5222 static tree
5223 check_inner_circular_reference (tree source, tree target)
5224 {
5225   tree base_binfo;
5226   tree ctx, cl;
5227   int i;
5228
5229   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (source), i, base_binfo); i++)
5230     {
5231       tree su;
5232
5233       /* We can end up with a NULL_TREE or an incomplete type here if
5234          we encountered previous type resolution errors. It's safe to
5235          simply ignore these cases.  */
5236       su = BINFO_TYPE (base_binfo);
5237       if (INCOMPLETE_TYPE_P (su))
5238         continue;
5239
5240       if (inherits_from_p (su, target))
5241         return lookup_cl (TYPE_NAME (su));
5242
5243       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5244         {
5245           /* An enclosing context shouldn't be TARGET */
5246           if (ctx == TYPE_NAME (target))
5247             return lookup_cl (TYPE_NAME (su));
5248
5249           /* When we reach the enclosing last context, start a check
5250              on it, with the same target */
5251           if (! DECL_CONTEXT (ctx) &&
5252               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5253             return cl;
5254         }
5255     }
5256   return NULL_TREE;
5257 }
5258
5259 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5260    offending type if a circularity is detected. NULL_TREE is returned
5261    otherwise. TYPE can be an interface or a class.   */
5262
5263 static tree
5264 check_circular_reference (tree type)
5265 {
5266   tree base_binfo;
5267   int i;
5268
5269   if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type)))
5270     return NULL_TREE;
5271
5272   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5273     {
5274       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5275         return lookup_cl (TYPE_NAME (type));
5276       return NULL_TREE;
5277     }
5278
5279   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (type), i, base_binfo); i++)
5280     {
5281       if (BINFO_TYPE (base_binfo) != object_type_node
5282           && interface_of_p (type, BINFO_TYPE (base_binfo)))
5283         return lookup_cl (TYPE_NAME (BINFO_TYPE (base_binfo)));
5284     }
5285   return NULL_TREE;
5286 }
5287
5288 void
5289 java_check_circular_reference (void)
5290 {
5291   tree current;
5292   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5293     {
5294       tree type = TREE_TYPE (current);
5295       tree cl;
5296
5297       cl = check_circular_reference (type);
5298       if (! cl)
5299         cl = check_inner_circular_reference (type, type);
5300       if (cl)
5301         parse_error_context (cl, "Cyclic class inheritance%s",
5302                              (cyclic_inheritance_report ?
5303                               cyclic_inheritance_report : ""));
5304     }
5305 }
5306
5307 /* Augment the parameter list PARM with parameters crafted to
5308    initialize outer context locals aliases. Through ARTIFICIAL, a
5309    count is kept of the number of crafted parameters. MODE governs
5310    what eventually gets created: something suitable for a function
5311    creation or a function invocation, either the constructor or
5312    finit$.  */
5313
5314 static tree
5315 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5316                                         int *artificial)
5317 {
5318   tree field;
5319   tree additional_parms = NULL_TREE;
5320
5321   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5322     if (FIELD_LOCAL_ALIAS (field))
5323       {
5324         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5325         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5326         tree mangled_id;
5327
5328         switch (mode)
5329           {
5330           case AIPL_FUNCTION_DECLARATION:
5331             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5332                                                          &buffer [4]);
5333             purpose = build_wfl_node (mangled_id);
5334             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5335               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5336             else
5337               value = TREE_TYPE (field);
5338             break;
5339
5340           case AIPL_FUNCTION_CREATION:
5341             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5342                                                          &buffer [4]);
5343             value = TREE_TYPE (field);
5344             break;
5345
5346           case AIPL_FUNCTION_FINIT_INVOCATION:
5347             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5348                                                          &buffer [4]);
5349             /* Now, this is wrong. purpose should always be the NAME
5350                of something and value its matching value (decl, type,
5351                etc...) FIXME -- but there is a lot to fix. */
5352
5353             /* When invoked for this kind of operation, we already
5354                know whether a field is used or not. */
5355             purpose = TREE_TYPE (field);
5356             value = build_wfl_node (mangled_id);
5357             break;
5358
5359           case AIPL_FUNCTION_CTOR_INVOCATION:
5360             /* There are two case: the constructor invocation happens
5361                outside the local inner, in which case, locales from the outer
5362                context are directly used.
5363
5364                Otherwise, we fold to using the alias directly. */
5365             if (class_type == current_class)
5366               value = field;
5367             else
5368               {
5369                 name = get_identifier (&buffer[4]);
5370                 value = IDENTIFIER_LOCAL_VALUE (name);
5371               }
5372             break;
5373           }
5374         additional_parms = tree_cons (purpose, value, additional_parms);
5375         if (artificial)
5376           *artificial +=1;
5377       }
5378   if (additional_parms)
5379     {
5380       if (ANONYMOUS_CLASS_P (class_type)
5381           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5382         additional_parms = nreverse (additional_parms);
5383       parm = chainon (additional_parms, parm);
5384     }
5385
5386    return parm;
5387 }
5388
5389 /* Craft a constructor for CLASS_DECL -- what we should do when none
5390    where found. ARGS is non NULL when a special signature must be
5391    enforced. This is the case for anonymous classes.  */
5392
5393 static tree
5394 craft_constructor (tree class_decl, tree args)
5395 {
5396   tree class_type = TREE_TYPE (class_decl);
5397   tree parm = NULL_TREE;
5398   /* Inherit access flags for the constructor from its enclosing class. */
5399   int valid_ctor_flags = ACC_PUBLIC | ACC_PROTECTED | ACC_PRIVATE;
5400   int flags = (get_access_flags_from_decl (class_decl) & valid_ctor_flags);
5401   int i = 0, artificial = 0;
5402   tree decl, ctor_name;
5403   char buffer [80];
5404
5405   /* The constructor name is <init> unless we're dealing with an
5406      anonymous class, in which case the name will be fixed after having
5407      be expanded. */
5408   if (ANONYMOUS_CLASS_P (class_type))
5409     ctor_name = DECL_NAME (class_decl);
5410   else
5411     ctor_name = init_identifier_node;
5412
5413   /* If we're dealing with an inner class constructor, we hide the
5414      this$<n> decl in the name field of its parameter declaration. */
5415   if (PURE_INNER_CLASS_TYPE_P (class_type))
5416     {
5417       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5418       parm = tree_cons (build_current_thisn (class_type),
5419                         build_pointer_type (type), parm);
5420
5421       /* Some more arguments to be hidden here. The values of the local
5422          variables of the outer context that the inner class needs to see. */
5423       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5424                                                      class_type, parm,
5425                                                      &artificial);
5426     }
5427
5428   /* Then if there are any args to be enforced, enforce them now */
5429   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5430     {
5431       sprintf (buffer, "parm%d", i++);
5432       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5433     }
5434
5435   CRAFTED_PARAM_LIST_FIXUP (parm);
5436   decl = create_artificial_method (class_type, flags, void_type_node,
5437                                    ctor_name, parm);
5438   fix_method_argument_names (parm, decl);
5439   /* Now, mark the artificial parameters. */
5440   DECL_FUNCTION_NAP (decl) = artificial;
5441   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5442   DECL_INLINE (decl) = 1;
5443   return decl;
5444 }
5445
5446
5447 /* Fix the constructors. This will be called right after circular
5448    references have been checked. It is necessary to fix constructors
5449    early even if no code generation will take place for that class:
5450    some generated constructor might be required by the class whose
5451    compilation triggered this one to be simply loaded.  */
5452
5453 void
5454 java_fix_constructors (void)
5455 {
5456   tree current;
5457
5458   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5459     {
5460       tree class_type = TREE_TYPE (current);
5461       int saw_ctor = 0;
5462       tree decl;
5463
5464       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5465         continue;
5466
5467       output_class = current_class = class_type;
5468       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5469         {
5470           if (DECL_CONSTRUCTOR_P (decl))
5471             {
5472               fix_constructors (decl);
5473               saw_ctor = 1;
5474             }
5475         }
5476
5477       /* Anonymous class constructor can't be generated that early. */
5478       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5479         craft_constructor (current, NULL_TREE);
5480     }
5481 }
5482
5483 /* safe_layout_class just makes sure that we can load a class without
5484    disrupting the current_class, input_file, input_line, etc, information
5485    about the class processed currently.  */
5486
5487 void
5488 safe_layout_class (tree class)
5489 {
5490   tree save_current_class = current_class;
5491   location_t save_location = input_location;
5492
5493   layout_class (class);
5494
5495   current_class = save_current_class;
5496   input_location = save_location;
5497 }
5498
5499 static tree
5500 jdep_resolve_class (jdep *dep)
5501 {
5502   tree decl;
5503
5504   if (JDEP_RESOLVED_P (dep))
5505     decl = JDEP_RESOLVED_DECL (dep);
5506   else
5507     {
5508       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5509                             JDEP_DECL (dep), JDEP_WFL (dep));
5510       JDEP_RESOLVED (dep, decl);
5511       /* If there is no WFL, that's ok.  We generate this warning
5512          elsewhere.  */
5513       if (decl && JDEP_WFL (dep) != NULL_TREE)
5514         check_deprecation (JDEP_WFL (dep), decl);
5515     }
5516
5517   if (!decl)
5518     complete_class_report_errors (dep);
5519   else if (INNER_CLASS_DECL_P (decl))
5520     {
5521       tree inner = TREE_TYPE (decl);
5522       if (! CLASS_LOADED_P (inner))
5523         {
5524           safe_layout_class (inner);
5525           if (TYPE_SIZE (inner) == error_mark_node)
5526             TYPE_SIZE (inner) = NULL_TREE;
5527         }
5528       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5529     }
5530   return decl;
5531 }
5532
5533 /* Complete unsatisfied class declaration and their dependencies */
5534
5535 void
5536 java_complete_class (void)
5537 {
5538   tree cclass;
5539   jdeplist *cclassd;
5540   int error_found;
5541   tree type;
5542
5543   /* Process imports */
5544   process_imports ();
5545
5546   /* Reverse things so we have the right order */
5547   ctxp->class_list = nreverse (ctxp->class_list);
5548   ctxp->classd_list = reverse_jdep_list (ctxp);
5549
5550   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5551        cclass && cclassd;
5552        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5553     {
5554       jdep *dep;
5555
5556       /* We keep the compilation unit imports in the class so that
5557          they can be used later to resolve type dependencies that
5558          aren't necessary to solve now. */
5559       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5560       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5561
5562       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5563         {
5564           tree decl;
5565           if (!(decl = jdep_resolve_class (dep)))
5566             continue;
5567
5568           /* Now it's time to patch */
5569           switch (JDEP_KIND (dep))
5570             {
5571             case JDEP_SUPER:
5572               /* Simply patch super */
5573               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5574                 continue;
5575               BINFO_TYPE (BINFO_BASE_BINFO
5576                           (TYPE_BINFO (TREE_TYPE (JDEP_DECL (dep))), 0))
5577                 = TREE_TYPE (decl);
5578               break;
5579
5580             case JDEP_FIELD:
5581               {
5582                 /* We do part of the job done in add_field */
5583                 tree field_decl = JDEP_DECL (dep);
5584                 tree field_type = TREE_TYPE (decl);
5585                 if (TREE_CODE (field_type) == RECORD_TYPE)
5586                   field_type = promote_type (field_type);
5587                 TREE_TYPE (field_decl) = field_type;
5588                 DECL_ALIGN (field_decl) = 0;
5589                 DECL_USER_ALIGN (field_decl) = 0;
5590                 layout_decl (field_decl, 0);
5591                 SOURCE_FRONTEND_DEBUG
5592                   (("Completed field/var decl `%s' with `%s'",
5593                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5594                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5595                 break;
5596               }
5597             case JDEP_METHOD:   /* We start patching a method */
5598             case JDEP_METHOD_RETURN:
5599               error_found = 0;
5600               while (1)
5601                 {
5602                   if (decl)
5603                     {
5604                       type = TREE_TYPE(decl);
5605                       if (TREE_CODE (type) == RECORD_TYPE)
5606                         type = promote_type (type);
5607                       JDEP_APPLY_PATCH (dep, type);
5608                       SOURCE_FRONTEND_DEBUG
5609                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5610                            "Completing fct `%s' with ret type `%s'":
5611                            "Completing arg `%s' with type `%s'"),
5612                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5613                                               (JDEP_DECL_WFL (dep))),
5614                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5615                     }
5616                   else
5617                     error_found = 1;
5618                   dep = JDEP_CHAIN (dep);
5619                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5620                     break;
5621                   else
5622                     decl = jdep_resolve_class (dep);
5623                 }
5624               if (!error_found)
5625                 {
5626                   tree mdecl = JDEP_DECL (dep), signature;
5627                   /* Recompute and reset the signature, check first that
5628                      all types are now defined. If they're not,
5629                      don't build the signature. */
5630                   if (check_method_types_complete (mdecl))
5631                     {
5632                       signature = build_java_signature (TREE_TYPE (mdecl));
5633                       set_java_signature (TREE_TYPE (mdecl), signature);
5634                     }
5635                 }
5636               else
5637                 continue;
5638               break;
5639
5640             case JDEP_INTERFACE:
5641               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5642                                                 JDEP_WFL (dep)))
5643                 continue;
5644               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5645               break;
5646
5647             case JDEP_PARM:
5648             case JDEP_VARIABLE:
5649               type = TREE_TYPE(decl);
5650               if (TREE_CODE (type) == RECORD_TYPE)
5651                 type = promote_type (type);
5652               JDEP_APPLY_PATCH (dep, type);
5653               break;
5654
5655             case JDEP_TYPE:
5656               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5657               SOURCE_FRONTEND_DEBUG
5658                 (("Completing a random type dependency on a '%s' node",
5659                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5660               break;
5661
5662             case JDEP_EXCEPTION:
5663               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5664               SOURCE_FRONTEND_DEBUG
5665                 (("Completing `%s' `throws' argument node",
5666                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5667               break;
5668
5669             case JDEP_ANONYMOUS:
5670               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5671               break;
5672
5673             default:
5674               abort ();
5675             }
5676         }
5677     }
5678   return;
5679 }
5680
5681 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5682    array.  */
5683
5684 static tree
5685 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5686 {
5687   tree tname = TYPE_NAME (class_type);
5688   tree resolved_type = TREE_TYPE (class_type);
5689   int array_dims = 0;
5690   tree resolved_type_decl;
5691
5692   if (resolved_type != NULL_TREE)
5693     {
5694       tree resolved_type_decl = TYPE_NAME (resolved_type);
5695       if (resolved_type_decl == NULL_TREE
5696           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5697         {
5698           resolved_type_decl = build_decl (TYPE_DECL,
5699                                            TYPE_NAME (class_type),
5700                                            resolved_type);
5701         }
5702       return resolved_type_decl;
5703     }
5704
5705   /* 1- Check to see if we have an array. If true, find what we really
5706      want to resolve  */
5707   if ((array_dims = build_type_name_from_array_name (tname,
5708                                                      &TYPE_NAME (class_type))))
5709     WFL_STRIP_BRACKET (cl, cl);
5710
5711   /* 2- Resolve the bare type */
5712   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5713                                                decl, cl)))
5714     return NULL_TREE;
5715   resolved_type = TREE_TYPE (resolved_type_decl);
5716
5717   /* 3- If we have an array, reconstruct the array down to its nesting */
5718   if (array_dims)
5719     {
5720       for (; array_dims; array_dims--)
5721         resolved_type = build_java_array_type (resolved_type, -1);
5722       resolved_type_decl = TYPE_NAME (resolved_type);
5723     }
5724   TREE_TYPE (class_type) = resolved_type;
5725   return resolved_type_decl;
5726 }
5727
5728 /* Effectively perform the resolution of class CLASS_TYPE.  DECL or CL
5729    are used to report error messages; CL must either be NULL_TREE or a
5730    WFL wrapping a class.  Do not try to replace TYPE_NAME (class_type)
5731    by a variable, since it is changed by find_in_imports{_on_demand}
5732    and (but it doesn't really matter) qualify_and_find.  */
5733
5734 tree
5735 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5736 {
5737   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5738   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5739   tree decl_result;
5740   htab_t circularity_hash;
5741
5742   if (QUALIFIED_P (TYPE_NAME (class_type)))
5743     {
5744       /* If the type name is of the form `Q . Id', then Q is either a
5745          package name or a class name.  First we try to find Q as a
5746          class and then treat Id as a member type.  If we can't find Q
5747          as a class then we fall through.  */
5748       tree q, left, left_type, right;
5749       if (split_qualified_name (&left, &right, TYPE_NAME (class_type)) == 0)
5750         {
5751           BUILD_PTR_FROM_NAME (left_type, left);
5752           q = do_resolve_class (enclosing, left_type, decl, cl);
5753           if (q)
5754             {
5755               enclosing = q;
5756               saved_enclosing_type = TREE_TYPE (q);
5757               BUILD_PTR_FROM_NAME (class_type, right);
5758             }
5759         }
5760     }
5761
5762   if (enclosing)
5763     {
5764       /* This hash table is used to register the classes we're going
5765          through when searching the current class as an inner class, in
5766          order to detect circular references. Remember to free it before
5767          returning the section 0- of this function. */
5768       circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5769                                       NULL);
5770
5771       /* 0- Search in the current class as an inner class.
5772          Maybe some code here should be added to load the class or
5773          something, at least if the class isn't an inner class and ended
5774          being loaded from class file. FIXME. */
5775       while (enclosing)
5776         {
5777           new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5778                                                 &super, class_type);
5779           if (new_class_decl)
5780             break;
5781
5782           /* If we haven't found anything because SUPER reached Object and
5783              ENCLOSING happens to be an innerclass, try the enclosing context. */
5784           if ((!super || super == object_type_node) &&
5785               enclosing && INNER_CLASS_DECL_P (enclosing))
5786             enclosing = DECL_CONTEXT (enclosing);
5787           else
5788             enclosing = NULL_TREE;
5789         }
5790
5791       htab_delete (circularity_hash);
5792
5793       if (new_class_decl)
5794         return new_class_decl;
5795     }
5796
5797   /* 1- Check for the type in single imports. This will change
5798      TYPE_NAME() if something relevant is found */
5799   find_in_imports (saved_enclosing_type, class_type);
5800
5801   /* 2- And check for the type in the current compilation unit */
5802   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5803     {
5804       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
5805         load_class (TYPE_NAME (class_type), 0);
5806       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5807     }
5808
5809   /* 3- Search according to the current package definition */
5810   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5811     {
5812       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5813                                              TYPE_NAME (class_type))))
5814         return new_class_decl;
5815     }
5816
5817   /* 4- Check the import on demands. Don't allow bar.baz to be
5818      imported from foo.* */
5819   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5820     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5821       return NULL_TREE;
5822
5823   /* If found in find_in_imports_on_demand, the type has already been
5824      loaded. */
5825   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5826     return new_class_decl;
5827
5828   /* 5- Try with a name qualified with the package name we've seen so far */
5829   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5830     {
5831       tree package;
5832
5833       /* If there is a current package (ctxp->package), it's the first
5834          element of package_list and we can skip it. */
5835       for (package = (ctxp->package ?
5836                       TREE_CHAIN (package_list) : package_list);
5837            package; package = TREE_CHAIN (package))
5838         if ((new_class_decl = qualify_and_find (class_type,
5839                                                TREE_PURPOSE (package),
5840                                                TYPE_NAME (class_type))))
5841           return new_class_decl;
5842     }
5843
5844   /* 5- Check another compilation unit that bears the name of type */
5845   load_class (TYPE_NAME (class_type), 0);
5846
5847   if (!cl)
5848     cl = lookup_cl (decl);
5849
5850   /* If we don't have a value for CL, then we're being called recursively.
5851      We can't check package access just yet, but it will be taken care of
5852      by the caller. */
5853   if (cl)
5854     {
5855       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true, NULL_TREE))
5856         return NULL_TREE;
5857     }
5858
5859   /* 6- Last call for a resolution */
5860   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5861
5862   /* The final lookup might have registered a.b.c into a.b$c If we
5863      failed at the first lookup, progressively change the name if
5864      applicable and use the matching DECL instead. */
5865   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5866     {
5867       char *separator;
5868       tree name = TYPE_NAME (class_type);
5869       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
5870
5871       strcpy (namebuffer, IDENTIFIER_POINTER (name));
5872
5873       do {
5874
5875        /* Reach the last '.', and if applicable, replace it by a `$' and
5876           see if this exists as a type. */
5877        if ((separator = strrchr (namebuffer, '.')))
5878          {
5879            *separator = '$';
5880            name = get_identifier (namebuffer);
5881            decl_result = IDENTIFIER_CLASS_VALUE (name);
5882          }
5883       } while (!decl_result && separator);
5884     }
5885   return decl_result;
5886 }
5887
5888 static tree
5889 qualify_and_find (tree class_type, tree package, tree name)
5890 {
5891   tree new_qualified = merge_qualified_name (package, name);
5892   tree new_class_decl;
5893
5894   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5895     load_class (new_qualified, 0);
5896   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5897     {
5898       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
5899         load_class (TREE_TYPE (new_class_decl), 0);
5900       TYPE_NAME (class_type) = new_qualified;
5901       return IDENTIFIER_CLASS_VALUE (new_qualified);
5902     }
5903   return NULL_TREE;
5904 }
5905
5906 /* Resolve NAME and lay it out (if not done and if not the current
5907    parsed class). Return a decl node. This function is meant to be
5908    called when type resolution is necessary during the walk pass.  */
5909
5910 static tree
5911 resolve_and_layout (tree something, tree cl)
5912 {
5913   tree decl, decl_type;
5914
5915   /* Don't do that on the current class */
5916   if (something == current_class)
5917     return TYPE_NAME (current_class);
5918
5919   /* Don't do anything for void and other primitive types */
5920   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5921     return NULL_TREE;
5922
5923   /* Pointer types can be reall pointer types or fake pointers. When
5924      finding a real pointer, recheck for primitive types */
5925   if (TREE_CODE (something) == POINTER_TYPE)
5926     {
5927       if (TREE_TYPE (something))
5928         {
5929           something = TREE_TYPE (something);
5930           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5931             return NULL_TREE;
5932         }
5933       else
5934         something = TYPE_NAME (something);
5935     }
5936
5937   /* Don't do anything for arrays of primitive types */
5938   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5939       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5940     return NULL_TREE;
5941
5942   /* Something might be a WFL */
5943   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5944     something = EXPR_WFL_NODE (something);
5945
5946   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5947      TYPE_DECL or a real TYPE */
5948   else if (TREE_CODE (something) != IDENTIFIER_NODE)
5949     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5950             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5951
5952   if (!(decl = resolve_no_layout (something, cl)))
5953     return NULL_TREE;
5954
5955   /* Resolve and layout if necessary */
5956   decl_type = TREE_TYPE (decl);
5957   layout_class_methods (decl_type);
5958   /* Check methods */
5959   if (CLASS_FROM_SOURCE_P (decl_type))
5960     java_check_methods (decl);
5961   /* Layout the type if necessary */
5962   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5963     safe_layout_class (decl_type);
5964
5965   return decl;
5966 }
5967
5968 /* Resolve a class, returns its decl but doesn't perform any
5969    layout. The current parsing context is saved and restored */
5970
5971 static tree
5972 resolve_no_layout (tree name, tree cl)
5973 {
5974   tree ptr, decl;
5975   BUILD_PTR_FROM_NAME (ptr, name);
5976   java_parser_context_save_global ();
5977   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5978   java_parser_context_restore_global ();
5979
5980   return decl;
5981 }
5982
5983 /* Called when reporting errors. Skip the '[]'s in a complex array
5984    type description that failed to be resolved. purify_type_name can't
5985    use an identifier tree.  */
5986
5987 static const char *
5988 purify_type_name (const char *name)
5989 {
5990   int len = strlen (name);
5991   int bracket_found;
5992
5993   STRING_STRIP_BRACKETS (name, len, bracket_found);
5994   if (bracket_found)
5995     {
5996       char *stripped_name = xmemdup (name, len, len+1);
5997       stripped_name [len] = '\0';
5998       return stripped_name;
5999     }
6000   return name;
6001 }
6002
6003 /* The type CURRENT refers to can't be found. We print error messages.  */
6004
6005 static void
6006 complete_class_report_errors (jdep *dep)
6007 {
6008   const char *name;
6009
6010   if (!JDEP_WFL (dep))
6011     return;
6012
6013   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6014   switch (JDEP_KIND (dep))
6015     {
6016     case JDEP_SUPER:
6017       parse_error_context
6018         (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
6019          purify_type_name (name),
6020          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6021       break;
6022     case JDEP_FIELD:
6023       parse_error_context
6024         (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
6025          purify_type_name (name),
6026          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6027       break;
6028     case JDEP_METHOD:           /* Covers arguments */
6029       parse_error_context
6030         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
6031          purify_type_name (name),
6032          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6033          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6034       break;
6035     case JDEP_METHOD_RETURN:    /* Covers return type */
6036       parse_error_context
6037         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
6038          purify_type_name (name),
6039          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6040       break;
6041     case JDEP_INTERFACE:
6042       parse_error_context
6043         (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
6044          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6045          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6046          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6047       break;
6048     case JDEP_VARIABLE:
6049       parse_error_context
6050         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
6051          purify_type_name (IDENTIFIER_POINTER
6052                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6053          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6054       break;
6055     case JDEP_EXCEPTION:        /* As specified by `throws' */
6056       parse_error_context
6057           (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6058          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6059       break;
6060     default:
6061       /* Fix for -Wall. Just break doing nothing. The error will be
6062          caught later */
6063       break;
6064     }
6065 }
6066
6067 /* Return a static string containing the DECL prototype string. If
6068    DECL is a constructor, use the class name instead of the form
6069    <init> */
6070
6071 static const char *
6072 get_printable_method_name (tree decl)
6073 {
6074   const char *to_return;
6075   tree name = NULL_TREE;
6076
6077   if (DECL_CONSTRUCTOR_P (decl))
6078     {
6079       name = DECL_NAME (decl);
6080       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6081     }
6082
6083   to_return = lang_printable_name (decl, 0);
6084   if (DECL_CONSTRUCTOR_P (decl))
6085     DECL_NAME (decl) = name;
6086
6087   return to_return;
6088 }
6089
6090 /* Track method being redefined inside the same class. As a side
6091    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6092    function it's a FWL, so we can track errors more accurately.)  */
6093
6094 static int
6095 check_method_redefinition (tree class, tree method)
6096 {
6097   tree redef, sig;
6098
6099   /* There's no need to verify <clinit> and finit$ and instinit$ */
6100   if (DECL_CLINIT_P (method)
6101       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6102     return 0;
6103
6104   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6105   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6106     {
6107       if (redef == method)
6108         break;
6109       if (DECL_NAME (redef) == DECL_NAME (method)
6110           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6111           && !DECL_ARTIFICIAL (method))
6112         {
6113           parse_error_context
6114             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6115              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6116              get_printable_method_name (redef));
6117           return 1;
6118         }
6119     }
6120   return 0;
6121 }
6122
6123 /* Return 1 if check went ok, 0 otherwise.  */
6124 static int
6125 check_abstract_method_definitions (int do_interface, tree class_decl,
6126                                    tree type)
6127 {
6128   tree class = TREE_TYPE (class_decl);
6129   tree method, end_type;
6130   int ok = 1;
6131
6132   end_type = (do_interface ? object_type_node : type);
6133   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6134     {
6135       tree other_super, other_method, method_sig, method_name;
6136       int found = 0;
6137       int end_type_reached = 0;
6138
6139       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6140         continue;
6141
6142       /* Now verify that somewhere in between TYPE and CLASS,
6143          abstract method METHOD gets a non abstract definition
6144          that is inherited by CLASS.  */
6145
6146       method_sig = build_java_signature (TREE_TYPE (method));
6147       method_name = DECL_NAME (method);
6148       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6149         method_name = EXPR_WFL_NODE (method_name);
6150
6151       other_super = class;
6152       do {
6153         if (other_super == end_type)
6154           end_type_reached = 1;
6155
6156         /* Method search */
6157         for (other_method = TYPE_METHODS (other_super); other_method;
6158             other_method = TREE_CHAIN (other_method))
6159           {
6160             tree s = build_java_signature (TREE_TYPE (other_method));
6161             tree other_name = DECL_NAME (other_method);
6162
6163             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6164               other_name = EXPR_WFL_NODE (other_name);
6165             if (!DECL_CLINIT_P (other_method)
6166                 && !DECL_CONSTRUCTOR_P (other_method)
6167                 && method_name == other_name
6168                 && method_sig == s
6169                 && !METHOD_ABSTRACT (other_method))
6170              {
6171                found = 1;
6172                break;
6173              }
6174           }
6175         other_super = CLASSTYPE_SUPER (other_super);
6176       } while (!end_type_reached);
6177
6178       /* Report that abstract METHOD didn't find an implementation
6179          that CLASS can use. */
6180       if (!found)
6181         {
6182           char *t = xstrdup (lang_printable_name
6183                             (TREE_TYPE (TREE_TYPE (method)), 0));
6184           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6185
6186           parse_error_context
6187             (lookup_cl (class_decl),
6188              "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",
6189              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6190              t, lang_printable_name (method, 0),
6191              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6192               "interface" : "class"),
6193              IDENTIFIER_POINTER (ccn),
6194              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6195              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6196           ok = 0;
6197           free (t);
6198         }
6199     }
6200
6201   if (ok && do_interface)
6202     {
6203       /* Check for implemented interfaces. */
6204       int i;
6205       tree base_binfo;
6206
6207       for (i = 1;
6208            ok && BINFO_BASE_ITERATE (TYPE_BINFO (type), i, base_binfo);
6209            i++)
6210         ok = check_abstract_method_definitions (1, class_decl,
6211                                                 BINFO_TYPE (base_binfo));
6212     }
6213
6214   return ok;
6215 }
6216
6217 /* Check that CLASS_DECL somehow implements all inherited abstract
6218    methods.  */
6219
6220 static void
6221 java_check_abstract_method_definitions (tree class_decl)
6222 {
6223   tree class = TREE_TYPE (class_decl);
6224   tree super, base_binfo;
6225   int i;
6226
6227   if (CLASS_ABSTRACT (class_decl))
6228     return;
6229
6230   /* Check for inherited types */
6231   super = class;
6232   do {
6233     super = CLASSTYPE_SUPER (super);
6234     check_abstract_method_definitions (0, class_decl, super);
6235   } while (super != object_type_node);
6236
6237   /* Check for implemented interfaces. */
6238   for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6239     check_abstract_method_definitions (1, class_decl, BINFO_TYPE (base_binfo));
6240 }
6241
6242 /* Check all the types method DECL uses and return 1 if all of them
6243    are now complete, 0 otherwise. This is used to check whether its
6244    safe to build a method signature or not.  */
6245
6246 static int
6247 check_method_types_complete (tree decl)
6248 {
6249   tree type = TREE_TYPE (decl);
6250   tree args;
6251
6252   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6253     return 0;
6254
6255   args = TYPE_ARG_TYPES (type);
6256   if (TREE_CODE (type) == METHOD_TYPE)
6257     args = TREE_CHAIN (args);
6258   for (; args != end_params_node; args = TREE_CHAIN (args))
6259     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6260       return 0;
6261
6262   return 1;
6263 }
6264
6265 /* Visible interface to check methods contained in CLASS_DECL */
6266
6267 void
6268 java_check_methods (tree class_decl)
6269 {
6270   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6271     return;
6272
6273   if (CLASS_INTERFACE (class_decl))
6274     java_check_abstract_methods (class_decl);
6275   else
6276     java_check_regular_methods (class_decl);
6277
6278   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6279 }
6280
6281 /* Like not_accessible_p, but doesn't refer to the current class at
6282    all.  */
6283 static bool
6284 hack_is_accessible_p (tree member, tree from_where)
6285 {
6286   int flags = get_access_flags_from_decl (member);
6287
6288   if (from_where == DECL_CONTEXT (member)
6289       || (flags & ACC_PUBLIC))
6290     return true;
6291
6292   if ((flags & ACC_PROTECTED))
6293     {
6294       if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6295         return true;
6296     }
6297
6298   if ((flags & ACC_PRIVATE))
6299     return false;
6300
6301   /* Package private, or protected.  */
6302   return in_same_package (TYPE_NAME (from_where),
6303                           TYPE_NAME (DECL_CONTEXT (member)));
6304 }
6305
6306 /* Check all the methods of CLASS_DECL. Methods are first completed
6307    then checked according to regular method existence rules.  If no
6308    constructor for CLASS_DECL were encountered, then build its
6309    declaration.  */
6310 static void
6311 java_check_regular_methods (tree class_decl)
6312 {
6313   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6314   tree method;
6315   tree class = TREE_TYPE (class_decl);
6316   tree found = NULL_TREE;
6317   tree mthrows;
6318
6319   /* It is not necessary to check methods defined in java.lang.Object */
6320   if (class == object_type_node)
6321     return;
6322
6323   if (!TYPE_NVIRTUALS (class))
6324     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6325
6326   /* Should take interfaces into account. FIXME */
6327   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6328     {
6329       tree sig;
6330       tree method_wfl = DECL_FUNCTION_WFL (method);
6331       int aflags;
6332
6333       /* Check for redefinitions */
6334       if (check_method_redefinition (class, method))
6335         continue;
6336
6337       /* We verify things thrown by the method.  They must inherit from
6338          java.lang.Throwable.  */
6339       for (mthrows = DECL_FUNCTION_THROWS (method);
6340            mthrows; mthrows = TREE_CHAIN (mthrows))
6341         {
6342           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6343             parse_error_context
6344               (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6345                IDENTIFIER_POINTER
6346                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6347         }
6348
6349       /* If we see one constructor a mark so we don't generate the
6350          default one.  Also skip other verifications: constructors
6351          can't be inherited hence hidden or overridden.  */
6352       if (DECL_CONSTRUCTOR_P (method))
6353         {
6354           saw_constructor = 1;
6355           continue;
6356         }
6357
6358       sig = build_java_argument_signature (TREE_TYPE (method));
6359       found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6360                                               SEARCH_SUPER | SEARCH_INTERFACE);
6361
6362       /* Inner class can't declare static methods */
6363       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6364         {
6365           char *t = xstrdup (lang_printable_name (class, 0));
6366           parse_error_context
6367             (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6368              lang_printable_name (method, 0), t);
6369           free (t);
6370         }
6371
6372       /* Nothing overrides or it's a private method. */
6373       if (!found)
6374         continue;
6375       if (METHOD_PRIVATE (found))
6376         {
6377           found = NULL_TREE;
6378           continue;
6379         }
6380
6381       /* If `found' is declared in an interface, make sure the
6382          modifier matches. */
6383       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6384           && clinit_identifier_node != DECL_NAME (found)
6385           && !METHOD_PUBLIC (method))
6386         {
6387           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6388           parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6389                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6390                                lang_printable_name (method, 0),
6391                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6392         }
6393
6394       /* Can't override a method with the same name and different return
6395          types. */
6396       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6397         {
6398           char *t = xstrdup
6399             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6400           parse_error_context
6401             (method_wfl,
6402              "Method `%s' was defined with return type `%s' in class `%s'",
6403              lang_printable_name (found, 0), t,
6404              IDENTIFIER_POINTER
6405                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6406           free (t);
6407         }
6408
6409       aflags = get_access_flags_from_decl (found);
6410
6411       /* Can't override final. Can't override static. */
6412       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6413         {
6414           /* Static *can* override static */
6415           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6416             continue;
6417           parse_error_context
6418             (method_wfl,
6419              "%s methods can't be overridden. Method `%s' is %s in class `%s'",
6420              (METHOD_FINAL (found) ? "Final" : "Static"),
6421              lang_printable_name (found, 0),
6422              (METHOD_FINAL (found) ? "final" : "static"),
6423              IDENTIFIER_POINTER
6424                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6425           continue;
6426         }
6427
6428       /* Static method can't override instance method. */
6429       if (METHOD_STATIC (method))
6430         {
6431           parse_error_context
6432             (method_wfl,
6433              "Instance methods can't be overridden by a static method. Method `%s' is an instance method in class `%s'",
6434              lang_printable_name (found, 0),
6435              IDENTIFIER_POINTER
6436                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6437           continue;
6438         }
6439
6440       /* - Overriding/hiding public must be public
6441          - Overriding/hiding protected must be protected or public
6442          - If the overridden or hidden method has default (package)
6443            access, then the overriding or hiding method must not be
6444            private; otherwise, a compile-time error occurs.  If
6445            `found' belongs to an interface, things have been already
6446            taken care of.  */
6447       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6448           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6449               || (METHOD_PROTECTED (found)
6450                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6451               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6452                   && METHOD_PRIVATE (method))))
6453         {
6454           parse_error_context
6455             (method_wfl,
6456              "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6457              (METHOD_PUBLIC (method) ? "public" :
6458               (METHOD_PRIVATE (method) ? "private" : "protected")),
6459              IDENTIFIER_POINTER (DECL_NAME
6460                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6461           continue;
6462         }
6463
6464       /* Check this method against all the other implementations it
6465          overrides.  Here we only check the class hierarchy; the rest
6466          of the checking is done later.  If this method is just a
6467          Miranda method, we can skip the check.  */
6468       if (! METHOD_INVISIBLE (method))
6469         check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6470     }
6471
6472   /* The above throws clause check only looked at superclasses.  Now
6473      we must also make sure that all methods declared in interfaces
6474      have compatible throws clauses.  FIXME: there are more efficient
6475      ways to organize this checking; we should implement one.  */
6476   check_interface_throws_clauses (class, class);
6477
6478   if (!TYPE_NVIRTUALS (class))
6479     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6480
6481   /* Search for inherited abstract method not yet implemented in this
6482      class.  */
6483   java_check_abstract_method_definitions (class_decl);
6484
6485   if (!saw_constructor)
6486     abort ();
6487 }
6488
6489 /* Check to make sure that all the methods in all the interfaces
6490    implemented by CLASS_DECL are compatible with the concrete
6491    implementations available in CHECK_CLASS_DECL.  */
6492 static void
6493 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6494 {
6495   for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6496     {
6497       int i;
6498
6499       if (! CLASS_LOADED_P (class_decl))
6500         {
6501           if (CLASS_FROM_SOURCE_P (class_decl))
6502             safe_layout_class (class_decl);
6503           else
6504             load_class (class_decl, 1);
6505         }
6506
6507       for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (class_decl)) - 1; i > 0; --i)
6508         {
6509           tree interface
6510             = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (class_decl), i));
6511           tree iface_method;
6512
6513           for (iface_method = TYPE_METHODS (interface);
6514                iface_method != NULL_TREE;
6515                iface_method = TREE_CHAIN (iface_method))
6516             {
6517               tree sig, method;
6518
6519               /* First look for a concrete method implemented or
6520                  inherited by this class.  No need to search
6521                  interfaces here, since we're already looking through
6522                  all of them.  */
6523               sig = build_java_argument_signature (TREE_TYPE (iface_method));
6524               method
6525                 = lookup_argument_method_generic (check_class_decl,
6526                                                   DECL_NAME (iface_method),
6527                                                   sig, SEARCH_VISIBLE);
6528               /* If we don't find an implementation, that is ok.  Any
6529                  potential errors from that are diagnosed elsewhere.
6530                  Also, multiple inheritance with conflicting throws
6531                  clauses is fine in the absence of a concrete
6532                  implementation.  */
6533               if (method != NULL_TREE && !METHOD_ABSTRACT (method)
6534                   && !METHOD_INVISIBLE (iface_method))
6535                 {
6536                   tree method_wfl = DECL_FUNCTION_WFL (method);
6537                   check_throws_clauses (method, method_wfl, iface_method);
6538                 }
6539             }
6540
6541           /* Now check superinterfaces.  */
6542           check_interface_throws_clauses (check_class_decl, interface);
6543         }
6544     }
6545 }
6546
6547 /* Check throws clauses of a method against the clauses of all the
6548    methods it overrides.  We do this by searching up the class
6549    hierarchy, examining all matching accessible methods.  */
6550 static void
6551 check_concrete_throws_clauses (tree class, tree self_method,
6552                                tree name, tree signature)
6553 {
6554   tree method = lookup_argument_method_generic (class, name, signature,
6555                                                 SEARCH_SUPER | SEARCH_VISIBLE);
6556   while (method != NULL_TREE)
6557     {
6558       if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6559         check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6560                               method);
6561
6562       method = lookup_argument_method_generic (DECL_CONTEXT (method),
6563                                                name, signature,
6564                                                SEARCH_SUPER | SEARCH_VISIBLE);
6565     }
6566 }
6567
6568 /* Generate an error if the `throws' clause of METHOD (if any) is
6569    incompatible with the `throws' clause of FOUND (if any).  */
6570 static void
6571 check_throws_clauses (tree method, tree method_wfl, tree found)
6572 {
6573   tree mthrows;
6574
6575   /* Can't check these things with class loaded from bytecode. FIXME */
6576   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6577     return;
6578
6579   for (mthrows = DECL_FUNCTION_THROWS (method);
6580        mthrows; mthrows = TREE_CHAIN (mthrows))
6581     {
6582       tree fthrows;
6583
6584       /* We don't verify unchecked expressions */
6585       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6586         continue;
6587       /* Checked expression must be compatible */
6588       for (fthrows = DECL_FUNCTION_THROWS (found);
6589            fthrows; fthrows = TREE_CHAIN (fthrows))
6590         {
6591           if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6592             break;
6593         }
6594       if (!fthrows)
6595         {
6596           parse_error_context
6597             (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'",
6598              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6599              lang_printable_name (found, 0),
6600              IDENTIFIER_POINTER
6601              (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6602         }
6603     }
6604 }
6605
6606 /* Check abstract method of interface INTERFACE */
6607 static void
6608 java_check_abstract_methods (tree interface_decl)
6609 {
6610   int i;
6611   tree method, found;
6612   tree interface = TREE_TYPE (interface_decl);
6613   tree base_binfo;
6614
6615   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6616     {
6617       /* 2- Check for double definition inside the defining interface */
6618       if (check_method_redefinition (interface, method))
6619         continue;
6620
6621       /* 3- Overriding is OK as far as we preserve the return type.  */
6622       found = lookup_java_interface_method2 (interface, method);
6623       if (found)
6624         {
6625           char *t;
6626           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6627           parse_error_context
6628             (DECL_FUNCTION_WFL (found),
6629              "Method `%s' was defined with return type `%s' in class `%s'",
6630              lang_printable_name (found, 0), t,
6631              IDENTIFIER_POINTER
6632                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6633           free (t);
6634           continue;
6635         }
6636     }
6637
6638   /* 4- Inherited methods can't differ by their returned types */
6639   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (interface), i, base_binfo); i++)
6640     {
6641       tree sub_interface_method, sub_interface;
6642
6643       sub_interface = BINFO_TYPE (base_binfo);
6644       for (sub_interface_method = TYPE_METHODS (sub_interface);
6645            sub_interface_method;
6646            sub_interface_method = TREE_CHAIN (sub_interface_method))
6647         {
6648           found = lookup_java_interface_method2 (interface,
6649                                                  sub_interface_method);
6650           if (found && (found != sub_interface_method))
6651             {
6652               parse_error_context
6653                 (lookup_cl (sub_interface_method),
6654                  "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6655                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6656                  lang_printable_name (found, 0),
6657                  IDENTIFIER_POINTER
6658                    (DECL_NAME (TYPE_NAME
6659                                (DECL_CONTEXT (sub_interface_method)))),
6660                  IDENTIFIER_POINTER
6661                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6662             }
6663         }
6664     }
6665 }
6666
6667 /* Lookup methods in interfaces using their name and partial
6668    signature. Return a matching method only if their types differ.  */
6669
6670 static tree
6671 lookup_java_interface_method2 (tree class, tree method_decl)
6672 {
6673   int i;
6674   tree base_binfo;
6675   tree to_return;
6676
6677   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6678     {
6679       if ((BINFO_TYPE (base_binfo) != object_type_node)
6680           && (to_return =
6681               lookup_java_method2 (BINFO_TYPE (base_binfo), method_decl, 1)))
6682         return to_return;
6683     }
6684   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6685     {
6686       to_return = lookup_java_interface_method2
6687         (BINFO_TYPE (base_binfo), method_decl);
6688       if (to_return)
6689         return to_return;
6690     }
6691
6692   return NULL_TREE;
6693 }
6694
6695 /* Lookup method using their name and partial signature. Return a
6696    matching method only if their types differ.  */
6697
6698 static tree
6699 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6700 {
6701   tree method, method_signature, method_name, method_type, name;
6702
6703   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6704   name = DECL_NAME (method_decl);
6705   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6706                  EXPR_WFL_NODE (name) : name);
6707   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6708
6709   while (clas != NULL_TREE)
6710     {
6711       for (method = TYPE_METHODS (clas);
6712            method != NULL_TREE;  method = TREE_CHAIN (method))
6713         {
6714           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6715           tree name = DECL_NAME (method);
6716           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6717                EXPR_WFL_NODE (name) : name) == method_name
6718               && method_sig == method_signature
6719               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6720             return method;
6721         }
6722       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6723     }
6724   return NULL_TREE;
6725 }
6726
6727 /* Return the line that matches DECL line number, and try its best to
6728    position the column number. Used during error reports.  */
6729
6730 static GTY(()) tree cl_v;
6731 static tree
6732 lookup_cl (tree decl)
6733 {
6734   char *line, *found;
6735
6736   if (!decl)
6737     return NULL_TREE;
6738
6739   if (cl_v == NULL_TREE)
6740     {
6741       cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6742     }
6743
6744   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6745   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6746
6747   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6748                             EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6749
6750   found = strstr ((const char *)line,
6751                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6752   if (found)
6753     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6754
6755   return cl_v;
6756 }
6757
6758 /* Look for a simple name in the single-type import list */
6759
6760 static tree
6761 find_name_in_single_imports (tree name)
6762 {
6763   tree node;
6764
6765   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6766     if (TREE_VALUE (node) == name)
6767       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6768
6769   return NULL_TREE;
6770 }
6771
6772 /* Process all single-type import. */
6773
6774 static int
6775 process_imports (void)
6776 {
6777   tree import;
6778   int error_found;
6779
6780   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6781     {
6782       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6783       char *original_name;
6784
6785       original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6786                                IDENTIFIER_LENGTH (to_be_found),
6787                                IDENTIFIER_LENGTH (to_be_found) + 1);
6788
6789       /* Don't load twice something already defined. */
6790       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6791         continue;
6792
6793       while (1)
6794         {
6795           tree left;
6796
6797           QUALIFIED_P (to_be_found) = 1;
6798           load_class (to_be_found, 0);
6799           error_found =
6800             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true, NULL_TREE);
6801
6802           /* We found it, we can bail out */
6803           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6804             {
6805               check_deprecation (TREE_PURPOSE (import),
6806                                  IDENTIFIER_CLASS_VALUE (to_be_found));
6807               break;
6808             }
6809
6810           /* We haven't found it. Maybe we're trying to access an
6811              inner class.  The only way for us to know is to try again
6812              after having dropped a qualifier. If we can't break it further,
6813              we have an error. */
6814           if (split_qualified_name (&left, NULL, to_be_found))
6815             break;
6816
6817           to_be_found = left;
6818         }
6819       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6820         {
6821           parse_error_context (TREE_PURPOSE (import),
6822                                "Class or interface `%s' not found in import",
6823                                original_name);
6824           error_found = 1;
6825         }
6826
6827       free (original_name);
6828       if (error_found)
6829         return 1;
6830     }
6831   return 0;
6832 }
6833
6834 /* Possibly find and mark a class imported by a single-type import
6835    statement.  */
6836
6837 static void
6838 find_in_imports (tree enclosing_type, tree class_type)
6839 {
6840   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6841                  ctxp->import_list);
6842   while (import)
6843     {
6844       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6845         {
6846           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6847           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6848           return;
6849         }
6850       import = TREE_CHAIN (import);
6851     }
6852 }
6853
6854 static int
6855 note_possible_classname (const char *name, int len)
6856 {
6857   tree node;
6858   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6859     len = len - 5;
6860   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6861     len = len - 6;
6862   else
6863     return 0;
6864   node = ident_subst (name, len, "", '/', '.', "");
6865   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6866   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6867   return 1;
6868 }
6869
6870 /* Read a import directory, gathering potential match for further type
6871    references. Indifferently reads a filesystem or a ZIP archive
6872    directory.  */
6873
6874 static void
6875 read_import_dir (tree wfl)
6876 {
6877   tree package_id = EXPR_WFL_NODE (wfl);
6878   const char *package_name = IDENTIFIER_POINTER (package_id);
6879   int package_length = IDENTIFIER_LENGTH (package_id);
6880   DIR *dirp = NULL;
6881   JCF *saved_jcf = current_jcf;
6882
6883   int found = 0;
6884   int k;
6885   void *entry;
6886   struct buffer filename[1];
6887
6888   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6889     return;
6890   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6891
6892   BUFFER_INIT (filename);
6893   buffer_grow (filename, package_length + 100);
6894
6895   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6896     {
6897       const char *entry_name = jcf_path_name (entry);
6898       int entry_length = strlen (entry_name);
6899       if (jcf_path_is_zipfile (entry))
6900         {
6901           ZipFile *zipf;
6902           buffer_grow (filename, entry_length);
6903           memcpy (filename->data, entry_name, entry_length - 1);
6904           filename->data[entry_length-1] = '\0';
6905           zipf = opendir_in_zip ((const char *) filename->data, jcf_path_is_system (entry));
6906           if (zipf == NULL)
6907             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6908           else
6909             {
6910               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6911               BUFFER_RESET (filename);
6912               for (k = 0; k < package_length; k++)
6913                 {
6914                   char ch = package_name[k];
6915                   *filename->ptr++ = ch == '.' ? '/' : ch;
6916                 }
6917               *filename->ptr++ = '/';
6918
6919               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
6920                 {
6921                   const char *current_entry = ZIPDIR_FILENAME (zipd);
6922                   int current_entry_len = zipd->filename_length;
6923
6924                   if (current_entry_len >= BUFFER_LENGTH (filename)
6925                       && strncmp ((const char *) filename->data, current_entry,
6926                                   BUFFER_LENGTH (filename)) != 0)
6927                     continue;
6928                   found |= note_possible_classname (current_entry,
6929                                                     current_entry_len);
6930                 }
6931             }
6932         }
6933       else
6934         {
6935           BUFFER_RESET (filename);
6936           buffer_grow (filename, entry_length + package_length + 4);
6937           strcpy ((char *) filename->data, entry_name);
6938           filename->ptr = filename->data + entry_length;
6939           for (k = 0; k < package_length; k++)
6940             {
6941               char ch = package_name[k];
6942               *filename->ptr++ = ch == '.' ? '/' : ch;
6943             }
6944           *filename->ptr = '\0';
6945
6946           dirp = opendir ((const char *) filename->data);
6947           if (dirp == NULL)
6948             continue;
6949           *filename->ptr++ = '/';
6950           for (;;)
6951             {
6952               int len;
6953               const char *d_name;
6954               struct dirent *direntp = readdir (dirp);
6955               if (!direntp)
6956                 break;
6957               d_name = direntp->d_name;
6958               len = strlen (direntp->d_name);
6959               buffer_grow (filename, len+1);
6960               strcpy ((char *) filename->ptr, d_name);
6961               found |= note_possible_classname ((const char *) filename->data + entry_length,
6962                                                 package_length+len+1);
6963             }
6964           if (dirp)
6965             closedir (dirp);
6966         }
6967     }
6968
6969   free (filename->data);
6970
6971   /* Here we should have a unified way of retrieving an entry, to be
6972      indexed. */
6973   if (!found)
6974     {
6975       static int first = 1;
6976       if (first)
6977         {
6978           error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
6979           java_error_count++;
6980           first = 0;
6981         }
6982       else
6983         parse_error_context (wfl, "Package `%s' not found in import",
6984                              package_name);
6985       current_jcf = saved_jcf;
6986       return;
6987     }
6988   current_jcf = saved_jcf;
6989 }
6990
6991 /* Possibly find a type in the import on demands specified
6992    types. Returns 1 if an error occurred, 0 otherwise. Run through the
6993    entire list, to detected potential double definitions.  */
6994
6995 static int
6996 find_in_imports_on_demand (tree enclosing_type, tree class_type)
6997 {
6998   tree class_type_name = TYPE_NAME (class_type);
6999   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
7000                   ctxp->import_demand_list);
7001   tree cl = NULL_TREE;
7002   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
7003   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
7004   tree node;
7005
7006   for (; import; import = TREE_CHAIN (import))
7007     {
7008       int saved_lineno = input_line;
7009       int access_check;
7010       const char *id_name;
7011       tree decl, type_name_copy;
7012
7013       obstack_grow (&temporary_obstack,
7014                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
7015                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
7016       obstack_1grow (&temporary_obstack, '.');
7017       obstack_grow0 (&temporary_obstack,
7018                      IDENTIFIER_POINTER (class_type_name),
7019                      IDENTIFIER_LENGTH (class_type_name));
7020       id_name = obstack_finish (&temporary_obstack);
7021
7022       if (! (node = maybe_get_identifier (id_name)))
7023         continue;
7024
7025       /* Setup input_line so that it refers to the line of the import (in
7026          case we parse a class file and encounter errors */
7027       input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
7028
7029       type_name_copy = TYPE_NAME (class_type);
7030       TYPE_NAME (class_type) = node;
7031       QUALIFIED_P (node) = 1;
7032       decl = IDENTIFIER_CLASS_VALUE (node);
7033       access_check = -1;
7034       /* If there is no DECL set for the class or if the class isn't
7035          loaded and not seen in source yet, then load */
7036       if (!decl || ! CLASS_LOADED_P (TREE_TYPE (decl)))
7037         {
7038           load_class (node, 0);
7039           decl = IDENTIFIER_CLASS_VALUE (node);
7040         }
7041       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7042         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7043                                                false, NULL_TREE);
7044       else
7045         /* 6.6.1: Inner classes are subject to member access rules. */
7046         access_check = 0;
7047
7048       input_line = saved_lineno;
7049
7050       /* If the loaded class is not accessible or couldn't be loaded,
7051          we restore the original TYPE_NAME and process the next
7052          import. */
7053       if (access_check || !decl)
7054         {
7055           TYPE_NAME (class_type) = type_name_copy;
7056           continue;
7057         }
7058
7059       /* If the loaded class is accessible, we keep a tab on it to
7060          detect and report multiple inclusions. */
7061       if (IS_A_CLASSFILE_NAME (node))
7062         {
7063           if (seen_once < 0)
7064             {
7065               cl = TREE_PURPOSE (import);
7066               seen_once = 1;
7067             }
7068           else if (seen_once >= 0)
7069             {
7070               tree location = (cl ? cl : TREE_PURPOSE (import));
7071               tree package = (cl ? EXPR_WFL_NODE (cl) :
7072                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
7073               seen_once++;
7074               parse_error_context
7075                 (location,
7076                  "Type `%s' also potentially defined in package `%s'",
7077                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7078                  IDENTIFIER_POINTER (package));
7079             }
7080         }
7081       to_return = access_check;
7082     }
7083
7084   if (seen_once == 1)
7085     return to_return;
7086   else
7087     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7088 }
7089
7090 /* Add package NAME to the list of packages encountered so far. To
7091    speed up class lookup in do_resolve_class, we make sure a
7092    particular package is added only once.  */
7093
7094 static void
7095 register_package (tree name)
7096 {
7097   static htab_t pht;
7098   void **e;
7099
7100   if (pht == NULL)
7101     pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
7102
7103   e = htab_find_slot (pht, name, INSERT);
7104   if (*e == NULL)
7105     {
7106       package_list = chainon (package_list, build_tree_list (name, NULL));
7107       *e = name;
7108     }
7109 }
7110
7111 static tree
7112 resolve_package (tree pkg, tree *next, tree *type_name)
7113 {
7114   tree current;
7115   tree decl = NULL_TREE;
7116   *type_name = NULL_TREE;
7117
7118   /* The trick is to determine when the package name stops and were
7119      the name of something contained in the package starts. Then we
7120      return a fully qualified name of what we want to get. */
7121
7122   *next = EXPR_WFL_QUALIFICATION (pkg);
7123
7124   /* Try to progressively construct a type name */
7125   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7126     for (current = EXPR_WFL_QUALIFICATION (pkg);
7127          current; current = TREE_CHAIN (current))
7128       {
7129         /* If we don't have what we're expecting, exit now. TYPE_NAME
7130            will be null and the error caught later. */
7131         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7132           break;
7133         *type_name =
7134           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7135         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7136           {
7137             /* resolve_package should be used in a loop, hence we
7138                point at this one to naturally process the next one at
7139                the next iteration. */
7140             *next = current;
7141             break;
7142           }
7143       }
7144   return decl;
7145 }
7146
7147
7148 /* Check accessibility of inner classes according to member access rules.
7149    DECL is the inner class, ENCLOSING_DECL is the class from which the
7150    access is being attempted. */
7151
7152 static void
7153 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7154 {
7155   const char *access;
7156   tree enclosing_decl_type;
7157
7158   /* We don't issue an error message when CL is null. CL can be null
7159      as a result of processing a JDEP crafted by source_start_java_method
7160      for the purpose of patching its parm decl. But the error would
7161      have been already trapped when fixing the method's signature.
7162      DECL can also be NULL in case of earlier errors. */
7163   if (!decl || !cl)
7164     return;
7165
7166   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7167
7168   if (CLASS_PRIVATE (decl))
7169     {
7170       /* Access is permitted only within the body of the top-level
7171          class in which DECL is declared. */
7172       tree top_level = decl;
7173       while (DECL_CONTEXT (top_level))
7174         top_level = DECL_CONTEXT (top_level);
7175       while (DECL_CONTEXT (enclosing_decl))
7176         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7177       if (top_level == enclosing_decl)
7178         return;
7179       access = "private";
7180     }
7181   else if (CLASS_PROTECTED (decl))
7182     {
7183       tree decl_context;
7184       /* Access is permitted from within the same package... */
7185       if (in_same_package (decl, enclosing_decl))
7186         return;
7187
7188       /* ... or from within the body of a subtype of the context in which
7189          DECL is declared. */
7190       decl_context = DECL_CONTEXT (decl);
7191       while (enclosing_decl)
7192         {
7193           if (CLASS_INTERFACE (decl))
7194             {
7195               if (interface_of_p (TREE_TYPE (decl_context),
7196                                   enclosing_decl_type))
7197                 return;
7198             }
7199           else
7200             {
7201               /* Eww. The order of the arguments is different!! */
7202               if (inherits_from_p (enclosing_decl_type,
7203                                    TREE_TYPE (decl_context)))
7204                 return;
7205             }
7206           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7207         }
7208       access = "protected";
7209     }
7210   else if (! CLASS_PUBLIC (decl))
7211     {
7212       /* Access is permitted only from within the same package as DECL. */
7213       if (in_same_package (decl, enclosing_decl))
7214         return;
7215       access = "non-public";
7216     }
7217   else
7218     /* Class is public. */
7219     return;
7220
7221   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7222                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7223                        lang_printable_name (decl, 0), access);
7224 }
7225
7226 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7227    foreign package, it must be PUBLIC. Return 0 if no access
7228    violations were found, 1 otherwise. If VERBOSE is true and an error
7229    was found, it is reported and accounted for.  If CL is NULL then
7230    look it up with THIS_DECL.  */
7231
7232 static int
7233 check_pkg_class_access (tree class_name, tree cl, bool verbose, tree this_decl)
7234 {
7235   tree type;
7236
7237   if (!IDENTIFIER_CLASS_VALUE (class_name))
7238     return 0;
7239
7240   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7241     return 0;
7242
7243   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7244     {
7245       /* Access to a private class within the same package is
7246          allowed. */
7247       tree l, r;
7248       split_qualified_name (&l, &r, class_name);
7249       if (!QUALIFIED_P (class_name) && !ctxp->package)
7250         /* Both in the empty package. */
7251         return 0;
7252       if (l == ctxp->package)
7253         /* Both in the same package. */
7254         return 0;
7255
7256       if (verbose)
7257         parse_error_context
7258           (cl == NULL ? lookup_cl (this_decl): cl,
7259            "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7260            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7261            IDENTIFIER_POINTER (class_name));
7262       return 1;
7263     }
7264   return 0;
7265 }
7266
7267 /* Local variable declaration. */
7268
7269 static void
7270 declare_local_variables (int modifier, tree type, tree vlist)
7271 {
7272   tree decl, current, saved_type;
7273   tree type_wfl = NULL_TREE;
7274   int must_chain = 0;
7275   int final_p = 0;
7276
7277   /* Push a new block if statements were seen between the last time we
7278      pushed a block and now. Keep a count of blocks to close */
7279   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7280     {
7281       tree b = enter_block ();
7282       BLOCK_IS_IMPLICIT (b) = 1;
7283     }
7284
7285   if (modifier)
7286     {
7287       size_t i;
7288       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7289         if (1 << i & modifier)
7290           break;
7291       if (modifier == ACC_FINAL)
7292         final_p = 1;
7293       else
7294         {
7295           parse_error_context
7296             (ctxp->modifier_ctx [i],
7297              "Only `final' is allowed as a local variables modifier");
7298           return;
7299         }
7300     }
7301
7302   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7303      hold the TYPE value if a new incomplete has to be created (as
7304      opposed to being found already existing and reused). */
7305   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7306
7307   /* If TYPE is fully resolved and we don't have a reference, make one */
7308   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7309
7310   /* Go through all the declared variables */
7311   for (current = vlist, saved_type = type; current;
7312        current = TREE_CHAIN (current), type = saved_type)
7313     {
7314       tree other, real_type;
7315       tree wfl  = TREE_PURPOSE (current);
7316       tree name = EXPR_WFL_NODE (wfl);
7317       tree init = TREE_VALUE (current);
7318
7319       /* Process NAME, as it may specify extra dimension(s) for it */
7320       type = build_array_from_name (type, type_wfl, name, &name);
7321
7322       /* Variable redefinition check */
7323       if ((other = lookup_name_in_blocks (name)))
7324         {
7325           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7326                                        DECL_SOURCE_LINE (other));
7327           continue;
7328         }
7329
7330       /* Type adjustment. We may have just readjusted TYPE because
7331          the variable specified more dimensions. Make sure we have
7332          a reference if we can and don't have one already. */
7333       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7334
7335       real_type = GET_REAL_TYPE (type);
7336       /* Never layout this decl. This will be done when its scope
7337          will be entered */
7338       decl = build_decl (VAR_DECL, name, real_type);
7339       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7340       DECL_FINAL (decl) = final_p;
7341       BLOCK_CHAIN_DECL (decl);
7342
7343       /* If doing xreferencing, replace the line number with the WFL
7344          compound value */
7345       if (flag_emit_xref)
7346         DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7347
7348       /* Don't try to use an INIT statement when an error was found */
7349       if (init && java_error_count)
7350         init = NULL_TREE;
7351
7352       /* Remember it if this is an initialized-upon-declaration final
7353          variable.  */
7354       if (init && final_p)
7355         {
7356           DECL_LOCAL_FINAL_IUD (decl) = 1;
7357         }
7358
7359       /* Add the initialization function to the current function's code */
7360       if (init)
7361         {
7362           /* Name might have been readjusted */
7363           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7364           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7365           java_method_add_stmt (current_function_decl,
7366                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7367                                                       init));
7368         }
7369
7370       /* Setup dependency the type of the decl */
7371       if (must_chain)
7372         {
7373           jdep *dep;
7374           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7375           dep = CLASSD_LAST (ctxp->classd_list);
7376           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7377         }
7378     }
7379   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7380 }
7381
7382 /* Called during parsing. Build decls from argument list.  */
7383
7384 static void
7385 source_start_java_method (tree fndecl)
7386 {
7387   tree tem;
7388   tree parm_decl;
7389   int i;
7390
7391   if (!fndecl)
7392     return;
7393
7394   current_function_decl = fndecl;
7395
7396   /* New scope for the function */
7397   enter_block ();
7398   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7399        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7400     {
7401       tree type = TREE_VALUE (tem);
7402       tree name = TREE_PURPOSE (tem);
7403
7404       /* If type is incomplete. Create an incomplete decl and ask for
7405          the decl to be patched later */
7406       if (INCOMPLETE_TYPE_P (type))
7407         {
7408           jdep *jdep;
7409           tree real_type = GET_REAL_TYPE (type);
7410           parm_decl = build_decl (PARM_DECL, name, real_type);
7411           type = obtain_incomplete_type (type);
7412           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7413           jdep = CLASSD_LAST (ctxp->classd_list);
7414           JDEP_MISC (jdep) = name;
7415           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7416         }
7417       else
7418         parm_decl = build_decl (PARM_DECL, name, type);
7419
7420       /* Remember if a local variable was declared final (via its
7421          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7422       if (ARG_FINAL_P (tem))
7423         {
7424           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7425           DECL_FINAL (parm_decl) = 1;
7426         }
7427
7428       BLOCK_CHAIN_DECL (parm_decl);
7429     }
7430   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7431   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7432     nreverse (tem);
7433   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7434   DECL_MAX_LOCALS (current_function_decl) = i;
7435 }
7436
7437 /* Called during parsing. Creates an artificial method declaration.  */
7438
7439 static tree
7440 create_artificial_method (tree class, int flags, tree type,
7441                           tree name, tree args)
7442 {
7443   tree mdecl;
7444
7445   java_parser_context_save_global ();
7446   input_line = 0;
7447   mdecl = make_node (FUNCTION_TYPE);
7448   TREE_TYPE (mdecl) = type;
7449   TYPE_ARG_TYPES (mdecl) = args;
7450   mdecl = add_method (class, flags, name, build_java_signature (mdecl));
7451   java_parser_context_restore_global ();
7452   DECL_ARTIFICIAL (mdecl) = 1;
7453   return mdecl;
7454 }
7455
7456 /* Starts the body if an artificial method.  */
7457
7458 static void
7459 start_artificial_method_body (tree mdecl)
7460 {
7461   DECL_SOURCE_LINE (mdecl) = 1;
7462   DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7463   source_start_java_method (mdecl);
7464   enter_block ();
7465 }
7466
7467 static void
7468 end_artificial_method_body (tree mdecl)
7469 {
7470   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7471      It has to be evaluated first. (if mdecl is current_function_decl,
7472      we have an undefined behavior if no temporary variable is used.) */
7473   tree b = exit_block ();
7474   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7475   exit_block ();
7476 }
7477
7478 /* Dump a tree of some kind.  This is a convenience wrapper for the
7479    dump_* functions in tree-dump.c.  */
7480 static void
7481 dump_java_tree (enum tree_dump_index phase, tree t)
7482 {
7483   FILE *stream;
7484   int flags;
7485
7486   stream = dump_begin (phase, &flags);
7487   flags |= TDF_SLIM;
7488   if (stream)
7489     {
7490       dump_node (t, flags, stream);
7491       dump_end (phase, stream);
7492     }
7493 }
7494
7495 /* Terminate a function and expand its body.  */
7496
7497 static void
7498 source_end_java_method (void)
7499 {
7500   tree fndecl = current_function_decl;
7501
7502   if (!fndecl)
7503     return;
7504
7505   java_parser_context_save_global ();
7506   input_line = ctxp->last_ccb_indent1;
7507
7508   /* Turn function bodies with only a NOP expr null, so they don't get
7509      generated at all and we won't get warnings when using the -W
7510      -Wall flags. */
7511   if (IS_EMPTY_STMT (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))))
7512     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7513
7514   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
7515       && ! flag_emit_class_files
7516       && ! flag_emit_xref)
7517     finish_method (fndecl);
7518
7519   current_function_decl = NULL_TREE;
7520   java_parser_context_restore_global ();
7521   current_function_decl = NULL_TREE;
7522 }
7523
7524 /* Record EXPR in the current function block. Complements compound
7525    expression second operand if necessary.  */
7526
7527 tree
7528 java_method_add_stmt (tree fndecl, tree expr)
7529 {
7530   if (!GET_CURRENT_BLOCK (fndecl))
7531     return NULL_TREE;
7532   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7533 }
7534
7535 static tree
7536 add_stmt_to_block (tree b, tree type, tree stmt)
7537 {
7538   tree body = BLOCK_EXPR_BODY (b), c;
7539
7540   if (java_error_count)
7541     return body;
7542
7543   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7544     return body;
7545
7546   BLOCK_EXPR_BODY (b) = c;
7547   TREE_SIDE_EFFECTS (c) = 1;
7548   return c;
7549 }
7550
7551 /* Lays out the methods for the classes seen so far.  */
7552
7553 void
7554 java_layout_seen_class_methods (void)
7555 {
7556   tree previous_list = all_class_list;
7557   tree end = NULL_TREE;
7558   tree current;
7559
7560   while (1)
7561     {
7562       for (current = previous_list;
7563            current != end; current = TREE_CHAIN (current))
7564         {
7565           tree cls = TREE_TYPE (TREE_VALUE (current));
7566
7567           if (! CLASS_LOADED_P (cls))
7568             load_class (cls, 0);
7569
7570           layout_class_methods (cls);
7571         }
7572
7573       /* Note that new classes might have been added while laying out
7574          methods, changing the value of all_class_list.  */
7575
7576       if (previous_list != all_class_list)
7577         {
7578           end = previous_list;
7579           previous_list = all_class_list;
7580         }
7581       else
7582         break;
7583     }
7584 }
7585
7586 static GTY(()) tree stop_reordering;
7587 void
7588 java_reorder_fields (void)
7589 {
7590   tree current;
7591
7592   for (current = gclass_list; current; current = TREE_CHAIN (current))
7593     {
7594       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7595
7596       if (current_class == stop_reordering)
7597         break;
7598
7599       /* Reverse the fields, but leave the dummy field in front.
7600          Fields are already ordered for Object and Class */
7601       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7602           && current_class != class_type_node)
7603       {
7604         /* If the dummy field is there, reverse the right fields and
7605            just layout the type for proper fields offset */
7606         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7607           {
7608             tree fields = TYPE_FIELDS (current_class);
7609             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7610             TYPE_SIZE (current_class) = NULL_TREE;
7611           }
7612         /* We don't have a dummy field, we need to layout the class,
7613            after having reversed the fields */
7614         else
7615           {
7616             TYPE_FIELDS (current_class) =
7617               nreverse (TYPE_FIELDS (current_class));
7618             TYPE_SIZE (current_class) = NULL_TREE;
7619           }
7620       }
7621     }
7622   /* There are cases were gclass_list will be empty. */
7623   if (gclass_list)
7624     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7625 }
7626
7627 /* Layout the methods of all classes loaded in one way or another.
7628    Check methods of source parsed classes. Then reorder the
7629    fields and layout the classes or the type of all source parsed
7630    classes */
7631
7632 void
7633 java_layout_classes (void)
7634 {
7635   tree current;
7636   int save_error_count = java_error_count;
7637
7638   /* Layout the methods of all classes seen so far */
7639   java_layout_seen_class_methods ();
7640   java_parse_abort_on_error ();
7641   all_class_list = NULL_TREE;
7642
7643   /* Then check the methods of all parsed classes */
7644   for (current = gclass_list; current; current = TREE_CHAIN (current))
7645     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7646       java_check_methods (TREE_VALUE (current));
7647   java_parse_abort_on_error ();
7648
7649   for (current = gclass_list; current; current = TREE_CHAIN (current))
7650     {
7651       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7652       layout_class (current_class);
7653
7654       /* Error reported by the caller */
7655       if (java_error_count)
7656         return;
7657     }
7658
7659   /* We might have reloaded classes durign the process of laying out
7660      classes for code generation. We must layout the methods of those
7661      late additions, as constructor checks might use them */
7662   java_layout_seen_class_methods ();
7663   java_parse_abort_on_error ();
7664 }
7665
7666 /* Expand methods in the current set of classes remembered for
7667    generation.  */
7668
7669 static void
7670 java_complete_expand_classes (void)
7671 {
7672   tree current;
7673
7674   do_not_fold = flag_emit_xref;
7675
7676   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7677     if (!INNER_CLASS_DECL_P (current))
7678       java_complete_expand_class (current);
7679 }
7680
7681 /* Expand the methods found in OUTER, starting first by OUTER's inner
7682    classes, if any.  */
7683
7684 static void
7685 java_complete_expand_class (tree outer)
7686 {
7687   tree inner_list;
7688
7689   /* We need to go after all inner classes and start expanding them,
7690      starting with most nested ones. We have to do that because nested
7691      classes might add functions to outer classes */
7692
7693   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7694        inner_list; inner_list = TREE_CHAIN (inner_list))
7695     java_complete_expand_class (TREE_PURPOSE (inner_list));
7696
7697   java_complete_expand_methods (outer);
7698 }
7699
7700 /* Expand methods registered in CLASS_DECL. The general idea is that
7701    we expand regular methods first. This allows us get an estimate on
7702    how outer context local alias fields are really used so we can add
7703    to the constructor just enough code to initialize them properly (it
7704    also lets us generate finit$ correctly.) Then we expand the
7705    constructors and then <clinit>.  */
7706
7707 static void
7708 java_complete_expand_methods (tree class_decl)
7709 {
7710   tree clinit, decl, first_decl;
7711
7712   output_class = current_class = TREE_TYPE (class_decl);
7713
7714   /* Pre-expand <clinit> to figure whether we really need it or
7715      not. If we do need it, we pre-expand the static fields so they're
7716      ready to be used somewhere else. <clinit> will be fully expanded
7717      after we processed the constructors. */
7718   first_decl = TYPE_METHODS (current_class);
7719   clinit = maybe_generate_pre_expand_clinit (current_class);
7720
7721   /* Then generate finit$ (if we need to) because constructors will
7722    try to use it.*/
7723   if (TYPE_FINIT_STMT_LIST (current_class))
7724     java_complete_expand_method (generate_finit (current_class));
7725
7726   /* Then generate instinit$ (if we need to) because constructors will
7727      try to use it. */
7728   if (TYPE_II_STMT_LIST (current_class))
7729     java_complete_expand_method (generate_instinit (current_class));
7730
7731   /* Now do the constructors */
7732   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7733     {
7734       if (!DECL_CONSTRUCTOR_P (decl))
7735         continue;
7736       java_complete_expand_method (decl);
7737     }
7738
7739   /* First, do the ordinary methods. */
7740   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7741     {
7742       /* Ctors aren't part of this batch. */
7743       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7744         continue;
7745
7746       /* Skip abstract or native methods -- but do handle native
7747          methods when generating JNI stubs.  */
7748       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7749         {
7750           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7751           continue;
7752         }
7753
7754       if (METHOD_NATIVE (decl))
7755         {
7756           tree body;
7757           current_function_decl = decl;
7758           body = build_jni_stub (decl);
7759           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7760         }
7761
7762       java_complete_expand_method (decl);
7763     }
7764
7765   /* If there is indeed a <clinit>, fully expand it now */
7766   if (clinit)
7767     {
7768       /* Prevent the use of `this' inside <clinit> */
7769       ctxp->explicit_constructor_p = 1;
7770       java_complete_expand_method (clinit);
7771       ctxp->explicit_constructor_p = 0;
7772     }
7773
7774   /* We might have generated a class$ that we now want to expand */
7775   if (TYPE_DOT_CLASS (current_class))
7776     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7777
7778   /* Now verify constructor circularity (stop after the first one we
7779      prove wrong.) */
7780   if (!CLASS_INTERFACE (class_decl))
7781     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7782       if (DECL_CONSTRUCTOR_P (decl)
7783           && verify_constructor_circularity (decl, decl))
7784         break;
7785 }
7786
7787 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7788    safely used in some other methods/constructors.  */
7789
7790 static tree
7791 maybe_generate_pre_expand_clinit (tree class_type)
7792 {
7793   tree current, mdecl;
7794
7795   if (!TYPE_CLINIT_STMT_LIST (class_type))
7796     return NULL_TREE;
7797
7798   /* Go through all static fields and pre expand them */
7799   for (current = TYPE_FIELDS (class_type); current;
7800        current = TREE_CHAIN (current))
7801     if (FIELD_STATIC (current))
7802       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7803
7804   /* Then build the <clinit> method */
7805   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7806                                     clinit_identifier_node, end_params_node);
7807   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7808                        mdecl, NULL_TREE);
7809   start_artificial_method_body (mdecl);
7810
7811   /* We process the list of assignment we produced as the result of
7812      the declaration of initialized static field and add them as
7813      statement to the <clinit> method. */
7814   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7815        current = TREE_CHAIN (current))
7816     {
7817       tree stmt = current;
7818       /* We build the assignment expression that will initialize the
7819          field to its value. There are strict rules on static
7820          initializers (8.5). FIXME */
7821       if (TREE_CODE (stmt) != BLOCK && !IS_EMPTY_STMT (stmt))
7822         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7823       java_method_add_stmt (mdecl, stmt);
7824     }
7825
7826   end_artificial_method_body (mdecl);
7827
7828   /* Now we want to place <clinit> as the last method (because we need
7829      it at least for interface so that it doesn't interfere with the
7830      dispatch table based lookup. */
7831   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7832     {
7833       current = TREE_CHAIN (TYPE_METHODS (class_type));
7834       TYPE_METHODS (class_type) = current;
7835
7836       while (TREE_CHAIN (current))
7837         current = TREE_CHAIN (current);
7838
7839       TREE_CHAIN (current) = mdecl;
7840       TREE_CHAIN (mdecl) = NULL_TREE;
7841     }
7842
7843   return mdecl;
7844 }
7845
7846 /* Analyzes a method body and look for something that isn't a
7847    MODIFY_EXPR with a constant value.  */
7848
7849 static int
7850 analyze_clinit_body (tree this_class, tree bbody)
7851 {
7852   while (bbody)
7853     switch (TREE_CODE (bbody))
7854       {
7855       case BLOCK:
7856         bbody = BLOCK_EXPR_BODY (bbody);
7857         break;
7858
7859       case EXPR_WITH_FILE_LOCATION:
7860         bbody = EXPR_WFL_NODE (bbody);
7861         break;
7862
7863       case COMPOUND_EXPR:
7864         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
7865           return 1;
7866         bbody = TREE_OPERAND (bbody, 1);
7867         break;
7868
7869       case MODIFY_EXPR:
7870         /* If we're generating to class file and we're dealing with an
7871            array initialization, we return 1 to keep <clinit> */
7872         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
7873             && flag_emit_class_files)
7874           return 1;
7875
7876         /* There are a few cases where we're required to keep
7877            <clinit>:
7878            - If this is an assignment whose operand is not constant,
7879            - If this is an assignment to a non-initialized field,
7880            - If this field is not a member of the current class.
7881         */
7882         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
7883                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
7884                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
7885
7886       default:
7887         return 1;
7888       }
7889   return 0;
7890 }
7891
7892
7893 /* See whether we could get rid of <clinit>. Criteria are: all static
7894    final fields have constant initial values and the body of <clinit>
7895    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7896
7897 static int
7898 maybe_yank_clinit (tree mdecl)
7899 {
7900   tree type, current;
7901   tree fbody, bbody;
7902
7903   if (!DECL_CLINIT_P (mdecl))
7904     return 0;
7905
7906   /* If the body isn't empty, then we keep <clinit>. Note that if
7907      we're emitting classfiles, this isn't enough not to rule it
7908      out. */
7909   fbody = DECL_FUNCTION_BODY (mdecl);
7910   bbody = BLOCK_EXPR_BODY (fbody);
7911   if (bbody && bbody != error_mark_node)
7912     bbody = BLOCK_EXPR_BODY (bbody);
7913   else
7914     return 0;
7915   if (bbody && ! flag_emit_class_files && !IS_EMPTY_STMT (bbody))
7916     return 0;
7917
7918   type = DECL_CONTEXT (mdecl);
7919   current = TYPE_FIELDS (type);
7920
7921   for (current = (current ? TREE_CHAIN (current) : current);
7922        current; current = TREE_CHAIN (current))
7923     {
7924       tree f_init;
7925
7926       /* We're not interested in non-static fields.  */
7927       if (!FIELD_STATIC (current))
7928         continue;
7929
7930       /* Nor in fields without initializers. */
7931       f_init = DECL_INITIAL (current);
7932       if (f_init == NULL_TREE)
7933         continue;
7934
7935       /* Anything that isn't String or a basic type is ruled out -- or
7936          if we know how to deal with it (when doing things natively) we
7937          should generated an empty <clinit> so that SUID are computed
7938          correctly. */
7939       if (! JSTRING_TYPE_P (TREE_TYPE (current))
7940           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
7941         return 0;
7942
7943       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
7944         return 0;
7945     }
7946
7947   /* Now we analyze the method body and look for something that
7948      isn't a MODIFY_EXPR */
7949   if (!IS_EMPTY_STMT (bbody) && analyze_clinit_body (type, bbody))
7950     return 0;
7951
7952   /* Get rid of <clinit> in the class' list of methods */
7953   if (TYPE_METHODS (type) == mdecl)
7954     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7955   else
7956     for (current = TYPE_METHODS (type); current;
7957          current = TREE_CHAIN (current))
7958       if (TREE_CHAIN (current) == mdecl)
7959         {
7960           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7961           break;
7962         }
7963
7964   return 1;
7965 }
7966
7967 /* Install the argument from MDECL. Suitable to completion and
7968    expansion of mdecl's body.  */
7969
7970 void
7971 start_complete_expand_method (tree mdecl)
7972 {
7973   tree tem;
7974
7975   pushlevel (1);                /* Prepare for a parameter push */
7976   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7977   DECL_ARGUMENTS (mdecl) = tem;
7978
7979   for (; tem; tem = TREE_CHAIN (tem))
7980     {
7981       /* TREE_CHAIN (tem) will change after pushdecl. */
7982       tree next = TREE_CHAIN (tem);
7983       tree type = TREE_TYPE (tem);
7984       if (targetm.calls.promote_prototypes (type)
7985           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
7986           && INTEGRAL_TYPE_P (type))
7987         type = integer_type_node;
7988       DECL_ARG_TYPE (tem) = type;
7989       layout_decl (tem, 0);
7990       pushdecl (tem);
7991       /* Re-install the next so that the list is kept and the loop
7992          advances. */
7993       TREE_CHAIN (tem) = next;
7994     }
7995   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
7996   input_line = DECL_SOURCE_LINE (mdecl);
7997   build_result_decl (mdecl);
7998 }
7999
8000
8001 /* Complete and expand a method.  */
8002
8003 static void
8004 java_complete_expand_method (tree mdecl)
8005 {
8006   tree fbody, block_body, exception_copy;
8007
8008   current_function_decl = mdecl;
8009   /* Fix constructors before expanding them */
8010   if (DECL_CONSTRUCTOR_P (mdecl))
8011     fix_constructors (mdecl);
8012
8013   /* Expand functions that have a body */
8014   if (!DECL_FUNCTION_BODY (mdecl))
8015     return;
8016
8017   fbody = DECL_FUNCTION_BODY (mdecl);
8018   block_body = BLOCK_EXPR_BODY (fbody);
8019   exception_copy = NULL_TREE;
8020
8021   current_function_decl = mdecl;
8022
8023   if (! quiet_flag)
8024     fprintf (stderr, " [%s.",
8025              lang_printable_name (DECL_CONTEXT (mdecl), 0));
8026   announce_function (mdecl);
8027   if (! quiet_flag)
8028     fprintf (stderr, "]");
8029
8030   /* Prepare the function for tree completion */
8031   start_complete_expand_method (mdecl);
8032
8033   /* Install the current this */
8034   current_this = (!METHOD_STATIC (mdecl) ?
8035                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8036
8037   /* Purge the `throws' list of unchecked exceptions (we save a copy
8038      of the list and re-install it later.) */
8039   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8040   purge_unchecked_exceptions (mdecl);
8041
8042   /* Install exceptions thrown with `throws' */
8043   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8044
8045   if (block_body != NULL_TREE)
8046     {
8047       block_body = java_complete_tree (block_body);
8048
8049       /* Before we check initialization, attached all class initialization
8050          variable to the block_body */
8051       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8052                      attach_init_test_initialization_flags, block_body);
8053
8054       if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
8055         {
8056           check_for_initialization (block_body, mdecl);
8057
8058           /* Go through all the flags marking the initialization of
8059              static variables and see whether they're definitively
8060              assigned, in which case the type is remembered as
8061              definitively initialized in MDECL. */
8062           if (STATIC_CLASS_INIT_OPT_P ())
8063             {
8064               /* Always register the context as properly initialized in
8065                  MDECL. This used with caution helps removing extra
8066                  initialization of self. */
8067               if (METHOD_STATIC (mdecl))
8068                 {
8069                   *(htab_find_slot
8070                     (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8071                      DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8072                 }
8073             }
8074         }
8075       ctxp->explicit_constructor_p = 0;
8076     }
8077
8078   BLOCK_EXPR_BODY (fbody) = block_body;
8079
8080   /* If we saw a return but couldn't evaluate it properly, we'll have
8081      an error_mark_node here. */
8082   if (block_body != error_mark_node
8083       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8084       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
8085       && !flag_emit_xref)
8086     missing_return_error (current_function_decl);
8087
8088   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8089   maybe_yank_clinit (mdecl);
8090
8091   /* Pop the current level, with special measures if we found errors. */
8092   if (java_error_count)
8093     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8094   poplevel (1, 0, 1);
8095
8096   /* Pop the exceptions and sanity check */
8097   POP_EXCEPTIONS();
8098   if (currently_caught_type_list)
8099     abort ();
8100
8101   /* Restore the copy of the list of exceptions if emitting xrefs. */
8102   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8103 }
8104
8105 /* For with each class for which there's code to generate. */
8106
8107 static void
8108 java_expand_method_bodies (tree class)
8109 {
8110   tree decl;
8111   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8112     {
8113       tree block;
8114
8115       if (! DECL_FUNCTION_BODY (decl))
8116         continue;
8117
8118       current_function_decl = decl;
8119
8120       block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8121
8122       /* Save the function body for gimplify and inlining.  */
8123       DECL_SAVED_TREE (decl) = block;
8124
8125       /* It's time to assign the variable flagging static class
8126          initialization based on which classes invoked static methods
8127          are definitely initializing. This should be flagged. */
8128       if (STATIC_CLASS_INIT_OPT_P ())
8129         {
8130           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8131           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8132             {
8133               /* Executed for each statement calling a static function.
8134                  LIST is a TREE_LIST whose PURPOSE is the called function
8135                  and VALUE is a compound whose second operand can be patched
8136                  with static class initialization flag assignments.  */
8137
8138               tree called_method = TREE_PURPOSE (list);
8139               tree compound = TREE_VALUE (list);
8140               tree assignment_compound_list
8141                 = build_tree_list (called_method, NULL);
8142
8143               /* For each class definitely initialized in
8144                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8145                  assignment to the class initialization flag. */
8146               htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8147                              emit_test_initialization,
8148                              assignment_compound_list);
8149
8150               if (TREE_VALUE (assignment_compound_list))
8151                 TREE_OPERAND (compound, 1)
8152                   = TREE_VALUE (assignment_compound_list);
8153             }
8154         }
8155
8156       /* Expand the function body.  */
8157       source_end_java_method ();
8158     }
8159 }
8160
8161 \f
8162
8163 /* This section of the code deals with accessing enclosing context
8164    fields either directly by using the relevant access to this$<n> or
8165    by invoking an access method crafted for that purpose.  */
8166
8167 /* Build the necessary access from an inner class to an outer
8168    class. This routine could be optimized to cache previous result
8169    (decl, current_class and returned access).  When an access method
8170    needs to be generated, it always takes the form of a read. It might
8171    be later turned into a write by calling outer_field_access_fix.  */
8172
8173 static tree
8174 build_outer_field_access (tree id, tree decl)
8175 {
8176   tree access = NULL_TREE;
8177   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8178   tree decl_ctx = DECL_CONTEXT (decl);
8179
8180   /* If the immediate enclosing context of the current class is the
8181      field decl's class or inherits from it; build the access as
8182      `this$<n>.<field>'. Note that we will break the `private' barrier
8183      if we're not emitting bytecodes. */
8184   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8185       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8186     {
8187       tree thisn = build_current_thisn (current_class);
8188       access = make_qualified_primary (build_wfl_node (thisn),
8189                                        id, EXPR_WFL_LINECOL (id));
8190     }
8191   /* Otherwise, generate access methods to outer this and access the
8192      field (either using an access method or by direct access.) */
8193   else
8194     {
8195       int lc = EXPR_WFL_LINECOL (id);
8196
8197       /* Now we chain the required number of calls to the access$0 to
8198          get a hold to the enclosing instance we need, and then we
8199          build the field access. */
8200       access = build_access_to_thisn (current_class, decl_ctx, lc);
8201
8202       /* If the field is private and we're generating bytecode, then
8203          we generate an access method */
8204       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8205         {
8206           tree name = build_outer_field_access_methods (decl);
8207           access = build_outer_field_access_expr (lc, decl_ctx,
8208                                                   name, access, NULL_TREE);
8209         }
8210       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8211          Once again we break the `private' access rule from a foreign
8212          class. */
8213       else
8214         access = make_qualified_primary (access, id, lc);
8215     }
8216   return resolve_expression_name (access, NULL);
8217 }
8218
8219 /* Return a nonzero value if NODE describes an outer field inner
8220    access.  */
8221
8222 static int
8223 outer_field_access_p (tree type, tree decl)
8224 {
8225   if (!INNER_CLASS_TYPE_P (type)
8226       || TREE_CODE (decl) != FIELD_DECL
8227       || DECL_CONTEXT (decl) == type)
8228     return 0;
8229
8230   /* If the inner class extends the declaration context of the field
8231      we're trying to access, then this isn't an outer field access */
8232   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8233     return 0;
8234
8235   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8236        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8237     {
8238       if (type == DECL_CONTEXT (decl))
8239         return 1;
8240
8241       if (!DECL_CONTEXT (TYPE_NAME (type)))
8242         {
8243           /* Before we give up, see whether the field is inherited from
8244              the enclosing context we're considering. */
8245           if (inherits_from_p (type, DECL_CONTEXT (decl)))
8246             return 1;
8247           break;
8248         }
8249     }
8250
8251   return 0;
8252 }
8253
8254 /* Return a nonzero value if NODE represents an outer field inner
8255    access that was been already expanded. As a side effect, it returns
8256    the name of the field being accessed and the argument passed to the
8257    access function, suitable for a regeneration of the access method
8258    call if necessary. */
8259
8260 static int
8261 outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8262                                tree *arg)
8263 {
8264   int identified = 0;
8265
8266   if (TREE_CODE (node) != CALL_EXPR)
8267     return 0;
8268
8269   /* Well, gcj generates slightly different tree nodes when compiling
8270      to native or bytecodes. It's the case for function calls. */
8271
8272   if (flag_emit_class_files
8273       && TREE_CODE (node) == CALL_EXPR
8274       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8275     identified = 1;
8276   else if (!flag_emit_class_files)
8277     {
8278       node = TREE_OPERAND (node, 0);
8279
8280       if (node && TREE_OPERAND (node, 0)
8281           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8282         {
8283           node = TREE_OPERAND (node, 0);
8284           if (TREE_OPERAND (node, 0)
8285               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8286               && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8287                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8288             identified = 1;
8289         }
8290     }
8291
8292   if (identified && name && arg_type && arg)
8293     {
8294       tree argument = TREE_OPERAND (node, 1);
8295       *name = DECL_NAME (TREE_OPERAND (node, 0));
8296       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8297       *arg = TREE_VALUE (argument);
8298     }
8299   return identified;
8300 }
8301
8302 /* Detect in NODE an outer field read access from an inner class and
8303    transform it into a write with RHS as an argument. This function is
8304    called from the java_complete_lhs when an assignment to a LHS can
8305    be identified. */
8306
8307 static tree
8308 outer_field_access_fix (tree wfl, tree node, tree rhs)
8309 {
8310   tree name, arg_type, arg;
8311
8312   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8313     {
8314       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8315                                             arg_type, name, arg, rhs);
8316       return java_complete_tree (node);
8317     }
8318   return NULL_TREE;
8319 }
8320
8321 /* Construct the expression that calls an access method:
8322      <type>.access$<n>(<arg1> [, <arg2>]);
8323
8324    ARG2 can be NULL and will be omitted in that case. It will denote a
8325    read access.  */
8326
8327 static tree
8328 build_outer_field_access_expr (int lc, tree type, tree access_method_name,
8329                                tree arg1, tree arg2)
8330 {
8331   tree args, cn, access;
8332
8333   args = arg1 ? arg1 :
8334     build_wfl_node (build_current_thisn (current_class));
8335   args = build_tree_list (NULL_TREE, args);
8336
8337   if (arg2)
8338     args = tree_cons (NULL_TREE, arg2, args);
8339
8340   access = build_method_invocation (build_wfl_node (access_method_name), args);
8341   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8342   return make_qualified_primary (cn, access, lc);
8343 }
8344
8345 static tree
8346 build_new_access_id (void)
8347 {
8348   static int access_n_counter = 1;
8349   char buffer [128];
8350
8351   sprintf (buffer, "access$%d", access_n_counter++);
8352   return get_identifier (buffer);
8353 }
8354
8355 /* Create the static access functions for the outer field DECL. We define a
8356    read:
8357      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8358        return inst$.field;
8359      }
8360    and a write access:
8361      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8362                                      TREE_TYPE (<field>) value$) {
8363        return inst$.field = value$;
8364      }
8365    We should have a usage flags on the DECL so we can lazily turn the ones
8366    we're using for code generation. FIXME.
8367 */
8368
8369 static tree
8370 build_outer_field_access_methods (tree decl)
8371 {
8372   tree id, args, stmt, mdecl;
8373
8374   if (FIELD_INNER_ACCESS_P (decl))
8375     return FIELD_INNER_ACCESS (decl);
8376
8377   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8378
8379   /* Create the identifier and a function named after it. */
8380   id = build_new_access_id ();
8381
8382   /* The identifier is marked as bearing the name of a generated write
8383      access function for outer field accessed from inner classes. */
8384   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8385
8386   /* Create the read access */
8387   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8388   TREE_CHAIN (args) = end_params_node;
8389   stmt = make_qualified_primary (build_wfl_node (inst_id),
8390                                  build_wfl_node (DECL_NAME (decl)), 0);
8391   stmt = build_return (0, stmt);
8392   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8393                                            TREE_TYPE (decl), id, args, stmt);
8394   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8395
8396   /* Create the write access method. No write access for final variable */
8397   if (!FIELD_FINAL (decl))
8398     {
8399       args = build_tree_list (inst_id,
8400                               build_pointer_type (DECL_CONTEXT (decl)));
8401       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8402       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8403       stmt = make_qualified_primary (build_wfl_node (inst_id),
8404                                      build_wfl_node (DECL_NAME (decl)), 0);
8405       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8406                                                 build_wfl_node (wpv_id)));
8407       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8408                                                TREE_TYPE (decl), id,
8409                                                args, stmt);
8410     }
8411   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8412
8413   /* Return the access name */
8414   return FIELD_INNER_ACCESS (decl) = id;
8415 }
8416
8417 /* Build an field access method NAME.  */
8418
8419 static tree
8420 build_outer_field_access_method (tree class, tree type, tree name,
8421                                  tree args, tree body)
8422 {
8423   tree saved_current_function_decl, mdecl;
8424
8425   /* Create the method */
8426   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8427   fix_method_argument_names (args, mdecl);
8428   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8429
8430   /* Attach the method body. */
8431   saved_current_function_decl = current_function_decl;
8432   start_artificial_method_body (mdecl);
8433   java_method_add_stmt (mdecl, body);
8434   end_artificial_method_body (mdecl);
8435   current_function_decl = saved_current_function_decl;
8436
8437   return mdecl;
8438 }
8439
8440 \f
8441 /* This section deals with building access function necessary for
8442    certain kinds of method invocation from inner classes.  */
8443
8444 static tree
8445 build_outer_method_access_method (tree decl)
8446 {
8447   tree saved_current_function_decl, mdecl;
8448   tree args = NULL_TREE, call_args = NULL_TREE;
8449   tree carg, id, body, class;
8450   char buffer [80];
8451   int parm_id_count = 0;
8452
8453   /* Test this abort with an access to a private field */
8454   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8455     abort ();
8456
8457   /* Check the cache first */
8458   if (DECL_FUNCTION_INNER_ACCESS (decl))
8459     return DECL_FUNCTION_INNER_ACCESS (decl);
8460
8461   class = DECL_CONTEXT (decl);
8462
8463   /* Obtain an access identifier and mark it */
8464   id = build_new_access_id ();
8465   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8466
8467   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8468   /* Create the arguments, as much as the original */
8469   for (; carg && carg != end_params_node;
8470        carg = TREE_CHAIN (carg))
8471     {
8472       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8473       args = chainon (args, build_tree_list (get_identifier (buffer),
8474                                              TREE_VALUE (carg)));
8475     }
8476   args = chainon (args, end_params_node);
8477
8478   /* Create the method */
8479   mdecl = create_artificial_method (class, ACC_STATIC,
8480                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8481   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8482   /* There is a potential bug here. We should be able to use
8483      fix_method_argument_names, but then arg names get mixed up and
8484      eventually a constructor will have its this$0 altered and the
8485      outer context won't be assignment properly. The testcase is
8486      stub.java FIXME */
8487   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8488
8489   /* Attach the method body. */
8490   saved_current_function_decl = current_function_decl;
8491   start_artificial_method_body (mdecl);
8492
8493   /* The actual method invocation uses the same args. When invoking a
8494      static methods that way, we don't want to skip the first
8495      argument. */
8496   carg = args;
8497   if (!METHOD_STATIC (decl))
8498     carg = TREE_CHAIN (carg);
8499   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8500     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8501                            call_args);
8502
8503   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8504                                   call_args);
8505   if (!METHOD_STATIC (decl))
8506     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8507                                    body, 0);
8508   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8509     body = build_return (0, body);
8510   java_method_add_stmt (mdecl,body);
8511   end_artificial_method_body (mdecl);
8512   current_function_decl = saved_current_function_decl;
8513
8514   /* Back tag the access function so it know what it accesses */
8515   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8516
8517   /* Tag the current method so it knows it has an access generated */
8518   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8519 }
8520
8521 \f
8522 /* This section of the code deals with building expressions to access
8523    the enclosing instance of an inner class. The enclosing instance is
8524    kept in a generated field called this$<n>, with <n> being the
8525    inner class nesting level (starting from 0.)  */
8526
8527 /* Build an access to a given this$<n>, always chaining access call to
8528    others. Access methods to this$<n> are build on the fly if
8529    necessary. This CAN'T be used to solely access this$<n-1> from
8530    this$<n> (which alway yield to special cases and optimization, see
8531    for example build_outer_field_access).  */
8532
8533 static tree
8534 build_access_to_thisn (tree from, tree to, int lc)
8535 {
8536   tree access = NULL_TREE;
8537
8538   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8539     {
8540       if (!access)
8541         {
8542           access = build_current_thisn (from);
8543           access = build_wfl_node (access);
8544         }
8545       else
8546         {
8547           tree access0_wfl, cn;
8548
8549           maybe_build_thisn_access_method (from);
8550           access0_wfl = build_wfl_node (access0_identifier_node);
8551           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8552           EXPR_WFL_LINECOL (access0_wfl) = lc;
8553           access = build_tree_list (NULL_TREE, access);
8554           access = build_method_invocation (access0_wfl, access);
8555           access = make_qualified_primary (cn, access, lc);
8556         }
8557
8558       /* If FROM isn't an inner class, that's fine, we've done enough.
8559          What we're looking for can be accessed from there.  */
8560       from = DECL_CONTEXT (TYPE_NAME (from));
8561       if (!from)
8562         break;
8563       from = TREE_TYPE (from);
8564     }
8565   return access;
8566 }
8567
8568 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8569    is returned if nothing needs to be generated. Otherwise, the method
8570    generated and a method decl is returned.
8571
8572    NOTE: These generated methods should be declared in a class file
8573    attribute so that they can't be referred to directly.  */
8574
8575 static tree
8576 maybe_build_thisn_access_method (tree type)
8577 {
8578   tree mdecl, args, stmt, rtype;
8579   tree saved_current_function_decl;
8580
8581   /* If TYPE is a top-level class, no access method is required.
8582      If there already is such an access method, bail out. */
8583   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8584     return NULL_TREE;
8585
8586   /* We generate the method. The method looks like:
8587      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8588   */
8589   args = build_tree_list (inst_id, build_pointer_type (type));
8590   TREE_CHAIN (args) = end_params_node;
8591   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8592   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8593                                     access0_identifier_node, args);
8594   fix_method_argument_names (args, mdecl);
8595   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8596   stmt = build_current_thisn (type);
8597   stmt = make_qualified_primary (build_wfl_node (inst_id),
8598                                  build_wfl_node (stmt), 0);
8599   stmt = build_return (0, stmt);
8600
8601   saved_current_function_decl = current_function_decl;
8602   start_artificial_method_body (mdecl);
8603   java_method_add_stmt (mdecl, stmt);
8604   end_artificial_method_body (mdecl);
8605   current_function_decl = saved_current_function_decl;
8606
8607   CLASS_ACCESS0_GENERATED_P (type) = 1;
8608
8609   return mdecl;
8610 }
8611
8612 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8613    the first level of innerclassing. this$1 for the next one, etc...
8614    This function can be invoked with TYPE to NULL, available and then
8615    has to count the parser context.  */
8616
8617 static GTY(()) tree saved_thisn;
8618 static GTY(()) tree saved_type;
8619
8620 static tree
8621 build_current_thisn (tree type)
8622 {
8623   static int saved_i = -1;
8624   static int saved_type_i = 0;
8625   tree decl;
8626   char buffer [24];
8627   int i = 0;
8628
8629   if (type)
8630     {
8631       if (type == saved_type)
8632         i = saved_type_i;
8633       else
8634         {
8635           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8636                decl; decl = DECL_CONTEXT (decl), i++)
8637             ;
8638
8639           saved_type = type;
8640           saved_type_i = i;
8641         }
8642     }
8643   else
8644     i = list_length (GET_CPC_LIST ())-2;
8645
8646   if (i == saved_i)
8647     return saved_thisn;
8648
8649   sprintf (buffer, "this$%d", i);
8650   saved_i = i;
8651   saved_thisn = get_identifier (buffer);
8652   return saved_thisn;
8653 }
8654
8655 /* Return the assignment to the hidden enclosing context `this$<n>'
8656    by the second incoming parameter to the innerclass constructor. The
8657    form used is `this.this$<n> = this$<n>;'.  */
8658
8659 static tree
8660 build_thisn_assign (void)
8661 {
8662   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8663     {
8664       tree thisn = build_current_thisn (current_class);
8665       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8666                                          build_wfl_node (thisn), 0);
8667       tree rhs = build_wfl_node (thisn);
8668       EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8669       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8670     }
8671   return NULL_TREE;
8672 }
8673
8674 \f
8675 /* Building the synthetic `class$' used to implement the `.class' 1.1
8676    extension for non primitive types. This method looks like:
8677
8678     static Class class$(String type) throws NoClassDefFoundError
8679     {
8680       try {return (java.lang.Class.forName (String));}
8681       catch (ClassNotFoundException e) {
8682         throw new NoClassDefFoundError(e.getMessage());}
8683     } */
8684
8685 static GTY(()) tree get_message_wfl;
8686 static GTY(()) tree type_parm_wfl;
8687
8688 static tree
8689 build_dot_class_method (tree class)
8690 {
8691 #define BWF(S) build_wfl_node (get_identifier ((S)))
8692 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8693   tree args, tmp, saved_current_function_decl, mdecl, qual_name;
8694   tree stmt, throw_stmt;
8695
8696   if (!get_message_wfl)
8697     {
8698       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8699       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8700     }
8701
8702   /* Build the arguments */
8703   args = build_tree_list (get_identifier ("type$"),
8704                           build_pointer_type (string_type_node));
8705   TREE_CHAIN (args) = end_params_node;
8706
8707   /* Build the qualified name java.lang.Class.forName */
8708   tmp = MQN (MQN (MQN (BWF ("java"),
8709                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8710
8711   /* Create the "class$" function */
8712   mdecl = create_artificial_method (class, ACC_STATIC,
8713                                     build_pointer_type (class_type_node),
8714                                     classdollar_identifier_node, args);
8715   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8716                    BWF ("NoClassDefFoundError"));
8717   DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE, qual_name);
8718   register_incomplete_type (JDEP_EXCEPTION, qual_name, NULL_TREE, NULL_TREE);
8719   JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
8720     &TREE_VALUE (DECL_FUNCTION_THROWS (mdecl));
8721
8722   /* We start by building the try block. We need to build:
8723        return (java.lang.Class.forName (type)); */
8724   stmt = build_method_invocation (tmp,
8725                                   build_tree_list (NULL_TREE, type_parm_wfl));
8726   stmt = build_return (0, stmt);
8727
8728   /* Now onto the catch block. We start by building the expression
8729      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8730   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8731                                     get_message_wfl, 0);
8732   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8733
8734   /* Build new NoClassDefFoundError (_.getMessage) */
8735   throw_stmt = build_new_invocation
8736     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8737      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8738
8739   /* Build the throw, (it's too early to use BUILD_THROW) */
8740   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8741
8742   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8743   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8744                    BWF ("ClassNotFoundException"));
8745   stmt = encapsulate_with_try_catch (0, qual_name, stmt, throw_stmt);
8746
8747   fix_method_argument_names (args, mdecl);
8748   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8749   saved_current_function_decl = current_function_decl;
8750   start_artificial_method_body (mdecl);
8751   java_method_add_stmt (mdecl, stmt);
8752   end_artificial_method_body (mdecl);
8753   current_function_decl = saved_current_function_decl;
8754   TYPE_DOT_CLASS (class) = mdecl;
8755
8756   return mdecl;
8757 }
8758
8759 static tree
8760 build_dot_class_method_invocation (tree this_class, tree type)
8761 {
8762   tree dot_class_method = TYPE_DOT_CLASS (this_class);
8763   tree sig_id, s, t;
8764
8765   if (TYPE_ARRAY_P (type))
8766     sig_id = build_java_signature (type);
8767   else
8768     sig_id = DECL_NAME (TYPE_NAME (type));
8769
8770   /* Ensure that the proper name separator is used */
8771   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8772                                IDENTIFIER_LENGTH (sig_id));
8773
8774   s = build_string (IDENTIFIER_LENGTH (sig_id),
8775                     IDENTIFIER_POINTER (sig_id));
8776   t = build_method_invocation (build_wfl_node (DECL_NAME (dot_class_method)),
8777                                build_tree_list (NULL_TREE, s));
8778   if (DECL_CONTEXT (dot_class_method) != this_class)
8779     {
8780       tree class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (dot_class_method)));
8781       t = make_qualified_primary (build_wfl_node (class_name), t, 0);
8782     }
8783   return t;
8784 }
8785
8786 /* This section of the code deals with constructor.  */
8787
8788 /* Craft a body for default constructor. Patch existing constructor
8789    bodies with call to super() and field initialization statements if
8790    necessary.  */
8791
8792 static void
8793 fix_constructors (tree mdecl)
8794 {
8795   tree iii;                     /* Instance Initializer Invocation */
8796   tree body = DECL_FUNCTION_BODY (mdecl);
8797   tree thisn_assign, compound = NULL_TREE;
8798   tree class_type = DECL_CONTEXT (mdecl);
8799
8800   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8801     return;
8802   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8803
8804   if (!body)
8805     {
8806       /* It is an error for the compiler to generate a default
8807          constructor if the superclass doesn't have a constructor that
8808          takes no argument, or the same args for an anonymous class */
8809       if (verify_constructor_super (mdecl))
8810         {
8811           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8812           tree save = DECL_NAME (mdecl);
8813           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8814           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8815           parse_error_context
8816             (lookup_cl (TYPE_NAME (class_type)),
8817              "No constructor matching `%s' found in class `%s'",
8818              lang_printable_name (mdecl, 0), n);
8819           DECL_NAME (mdecl) = save;
8820         }
8821
8822       /* The constructor body must be crafted by hand. It's the
8823          constructor we defined when we realize we didn't have the
8824          CLASSNAME() constructor */
8825       start_artificial_method_body (mdecl);
8826
8827       /* Insert an assignment to the this$<n> hidden field, if
8828          necessary */
8829       if ((thisn_assign = build_thisn_assign ()))
8830         java_method_add_stmt (mdecl, thisn_assign);
8831
8832       /* We don't generate a super constructor invocation if we're
8833          compiling java.lang.Object. build_super_invocation takes care
8834          of that. */
8835       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8836
8837       /* FIXME */
8838       if ((iii = build_instinit_invocation (class_type)))
8839         java_method_add_stmt (mdecl, iii);
8840
8841       end_artificial_method_body (mdecl);
8842     }
8843   /* Search for an explicit constructor invocation */
8844   else
8845     {
8846       int found = 0;
8847       int invokes_this = 0;
8848       tree found_call = NULL_TREE;
8849       tree main_block = BLOCK_EXPR_BODY (body);
8850
8851       while (body)
8852         switch (TREE_CODE (body))
8853           {
8854           case CALL_EXPR:
8855             found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8856             if (CALL_THIS_CONSTRUCTOR_P (body))
8857               invokes_this = 1;
8858             body = NULL_TREE;
8859             break;
8860           case COMPOUND_EXPR:
8861           case EXPR_WITH_FILE_LOCATION:
8862             found_call = body;
8863             body = TREE_OPERAND (body, 0);
8864             break;
8865           case BLOCK:
8866             found_call = body;
8867             body = BLOCK_EXPR_BODY (body);
8868             break;
8869           default:
8870             found = 0;
8871             body = NULL_TREE;
8872           }
8873
8874       /* Generate the assignment to this$<n>, if necessary */
8875       if ((thisn_assign = build_thisn_assign ()))
8876         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8877
8878       /* The constructor is missing an invocation of super() */
8879       if (!found)
8880         compound = add_stmt_to_compound (compound, NULL_TREE,
8881                                          build_super_invocation (mdecl));
8882       /* Explicit super() invocation should take place before the
8883          instance initializer blocks. */
8884       else
8885         {
8886           compound = add_stmt_to_compound (compound, NULL_TREE,
8887                                            TREE_OPERAND (found_call, 0));
8888           TREE_OPERAND (found_call, 0) = build_java_empty_stmt ();
8889         }
8890
8891       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
8892
8893       /* Insert the instance initializer block right after. */
8894       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
8895         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
8896
8897       /* Fix the constructor main block if we're adding extra stmts */
8898       if (compound)
8899         {
8900           compound = add_stmt_to_compound (compound, NULL_TREE,
8901                                            BLOCK_EXPR_BODY (main_block));
8902           BLOCK_EXPR_BODY (main_block) = compound;
8903         }
8904     }
8905 }
8906
8907 /* Browse constructors in the super class, searching for a constructor
8908    that doesn't take any argument. Return 0 if one is found, 1
8909    otherwise.  If the current class is an anonymous inner class, look
8910    for something that has the same signature. */
8911
8912 static int
8913 verify_constructor_super (tree mdecl)
8914 {
8915   tree class = CLASSTYPE_SUPER (current_class);
8916   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8917   tree sdecl;
8918
8919   if (!class)
8920     return 0;
8921
8922   if (ANONYMOUS_CLASS_P (current_class))
8923     {
8924       tree mdecl_arg_type;
8925       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8926       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8927         if (DECL_CONSTRUCTOR_P (sdecl))
8928           {
8929             tree m_arg_type;
8930             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8931             if (super_inner)
8932               arg_type = TREE_CHAIN (arg_type);
8933             for (m_arg_type = mdecl_arg_type;
8934                  (arg_type != end_params_node
8935                   && m_arg_type != end_params_node);
8936                  arg_type = TREE_CHAIN (arg_type),
8937                    m_arg_type = TREE_CHAIN (m_arg_type))
8938               if (!valid_method_invocation_conversion_p
8939                      (TREE_VALUE (arg_type),
8940                       TREE_VALUE (m_arg_type)))
8941                 break;
8942
8943             if (arg_type == end_params_node && m_arg_type == end_params_node)
8944               return 0;
8945           }
8946     }
8947   else
8948     {
8949       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8950         {
8951           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8952           if (super_inner)
8953             arg = TREE_CHAIN (arg);
8954           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
8955             return 0;
8956         }
8957     }
8958   return 1;
8959 }
8960
8961 /* Generate code for all context remembered for code generation.  */
8962
8963 static GTY(()) tree reversed_class_list;
8964 void
8965 java_expand_classes (void)
8966 {
8967   int save_error_count = 0;
8968   static struct parser_ctxt *cur_ctxp = NULL;
8969
8970   java_parse_abort_on_error ();
8971   if (!(ctxp = ctxp_for_generation))
8972     return;
8973   java_layout_classes ();
8974   java_parse_abort_on_error ();
8975
8976   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
8977     {
8978       tree current;
8979       for (current = cur_ctxp->class_list;
8980            current;
8981            current = TREE_CHAIN (current))
8982         gen_indirect_dispatch_tables (TREE_TYPE (current));
8983     }
8984
8985   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
8986     {
8987       ctxp = cur_ctxp;
8988       input_filename = ctxp->filename;
8989       lang_init_source (2);            /* Error msgs have method prototypes */
8990       java_complete_expand_classes (); /* Complete and expand classes */
8991       java_parse_abort_on_error ();
8992     }
8993   input_filename = main_input_filename;
8994
8995   /* Find anonymous classes and expand their constructor. This extra pass is
8996      necessary because the constructor itself is only generated when the
8997      method in which it is defined is expanded. */
8998   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
8999     {
9000       tree current;
9001       ctxp = cur_ctxp;
9002       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9003         {
9004           output_class = current_class = TREE_TYPE (current);
9005           if (ANONYMOUS_CLASS_P (current_class))
9006             {
9007               tree d;
9008               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9009                 {
9010                   if (DECL_CONSTRUCTOR_P (d))
9011                     {
9012                       java_complete_expand_method (d);
9013                       break;    /* There is only one constructor. */
9014                     }
9015                 }
9016             }
9017         }
9018     }
9019
9020   /* Expanding the constructors of anonymous classes generates access
9021      methods.  Scan all the methods looking for null DECL_RESULTs --
9022      this will be the case if a method hasn't been expanded.  */
9023   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9024     {
9025       tree current;
9026       ctxp = cur_ctxp;
9027       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9028         {
9029           tree d;
9030           output_class = current_class = TREE_TYPE (current);
9031           for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9032             {
9033               if (DECL_RESULT (d) == NULL_TREE)
9034                 java_complete_expand_method (d);
9035             }
9036         }
9037     }
9038
9039   /* ???  Instead of all this we could iterate around the list of
9040      classes until there were no more un-expanded methods.  It would
9041      take a little longer -- one pass over the whole list of methods
9042      -- but it would be simpler.  Like this:  */
9043 #if 0
9044     {
9045       int something_changed;
9046
9047       do
9048         {
9049           something_changed = 0;
9050           for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9051             {
9052               tree current;
9053               ctxp = cur_ctxp;
9054               for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9055                 {
9056                   tree d;
9057                   output_class = current_class = TREE_TYPE (current);
9058                   for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9059                     {
9060                       if (DECL_RESULT (d) == NULL_TREE)
9061                         {
9062                           something_changed = 1;
9063                           java_complete_expand_method (d);
9064                         }
9065                     }
9066                 }
9067             }
9068         }
9069       while (something_changed);
9070     }
9071 #endif
9072
9073   /* If we've found error at that stage, don't try to generate
9074      anything, unless we're emitting xrefs or checking the syntax only
9075      (but not using -fsyntax-only for the purpose of generating
9076      bytecode. */
9077   if (java_error_count && !flag_emit_xref
9078       && (!flag_syntax_only && !flag_emit_class_files))
9079     return;
9080
9081   /* Now things are stable, go for generation of the class data. */
9082
9083   /* We pessimistically marked all methods and fields external until
9084      we knew what set of classes we were planning to compile.  Now mark
9085      those that will be generated locally as not external.  */
9086   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9087     {
9088       tree current;
9089       ctxp = cur_ctxp;
9090       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9091         java_mark_class_local (TREE_TYPE (current));
9092     }
9093
9094   /* Compile the classes.  */
9095   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9096     {
9097       tree current;
9098       reversed_class_list = NULL;
9099
9100       ctxp = cur_ctxp;
9101
9102       /* We write out the classes in reverse order.  This ensures that
9103          inner classes are written before their containing classes,
9104          which is important for parallel builds.  Otherwise, the
9105          class file for the outer class may be found, but the class
9106          file for the inner class may not be present.  In that
9107          situation, the compiler cannot fall back to the original
9108          source, having already read the outer class, so we must
9109          prevent that situation.  */
9110       for (current = ctxp->class_list;
9111            current;
9112            current = TREE_CHAIN (current))
9113         reversed_class_list
9114           = tree_cons (NULL_TREE, current, reversed_class_list);
9115
9116       for (current = reversed_class_list;
9117            current;
9118            current = TREE_CHAIN (current))
9119         {
9120           output_class = current_class = TREE_TYPE (TREE_VALUE (current));
9121           if (flag_emit_class_files)
9122             write_classfile (current_class);
9123           if (flag_emit_xref)
9124             expand_xref (current_class);
9125           else if (! flag_syntax_only)
9126             java_expand_method_bodies (current_class);
9127         }
9128     }
9129 }
9130
9131 void
9132 java_finish_classes (void)
9133 {
9134   static struct parser_ctxt *cur_ctxp = NULL;
9135   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9136     {
9137       tree current;
9138       ctxp = cur_ctxp;
9139       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9140         {
9141           output_class = current_class = TREE_TYPE (current);
9142           finish_class ();
9143         }
9144     }
9145 }
9146
9147 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9148    a tree list node containing RIGHT. Fore coming RIGHTs will be
9149    chained to this hook. LOCATION contains the location of the
9150    separating `.' operator.  */
9151
9152 static tree
9153 make_qualified_primary (tree primary, tree right, int location)
9154 {
9155   tree wfl;
9156
9157   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9158     wfl = build_wfl_wrap (primary, location);
9159   else
9160     {
9161       wfl = primary;
9162       /* If wfl wasn't qualified, we build a first anchor */
9163       if (!EXPR_WFL_QUALIFICATION (wfl))
9164         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9165     }
9166
9167   /* And chain them */
9168   EXPR_WFL_LINECOL (right) = location;
9169   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9170   PRIMARY_P (wfl) =  1;
9171   return wfl;
9172 }
9173
9174 /* Simple merge of two name separated by a `.' */
9175
9176 static tree
9177 merge_qualified_name (tree left, tree right)
9178 {
9179   tree node;
9180   if (!left && !right)
9181     return NULL_TREE;
9182
9183   if (!left)
9184     return right;
9185
9186   if (!right)
9187     return left;
9188
9189   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9190                 IDENTIFIER_LENGTH (left));
9191   obstack_1grow (&temporary_obstack, '.');
9192   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9193                  IDENTIFIER_LENGTH (right));
9194   node =  get_identifier (obstack_base (&temporary_obstack));
9195   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9196   QUALIFIED_P (node) = 1;
9197   return node;
9198 }
9199
9200 /* Merge the two parts of a qualified name into LEFT.  Set the
9201    location information of the resulting node to LOCATION, usually
9202    inherited from the location information of the `.' operator. */
9203
9204 static tree
9205 make_qualified_name (tree left, tree right, int location)
9206 {
9207 #ifdef USE_COMPONENT_REF
9208   tree node = build3 (COMPONENT_REF, NULL_TREE, left, right, NULL_TREE);
9209   EXPR_WFL_LINECOL (node) = location;
9210   return node;
9211 #else
9212   tree left_id = EXPR_WFL_NODE (left);
9213   tree right_id = EXPR_WFL_NODE (right);
9214   tree wfl, merge;
9215
9216   merge = merge_qualified_name (left_id, right_id);
9217
9218   /* Left wasn't qualified and is now qualified */
9219   if (!QUALIFIED_P (left_id))
9220     {
9221       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9222       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9223       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9224     }
9225
9226   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9227   EXPR_WFL_LINECOL (wfl) = location;
9228   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9229
9230   EXPR_WFL_NODE (left) = merge;
9231   return left;
9232 #endif
9233 }
9234
9235 /* Extract the last identifier component of the qualified in WFL. The
9236    last identifier is removed from the linked list */
9237
9238 static tree
9239 cut_identifier_in_qualified (tree wfl)
9240 {
9241   tree q;
9242   tree previous = NULL_TREE;
9243   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9244     if (!TREE_CHAIN (q))
9245       {
9246         if (!previous)
9247           /* Operating on a non qualified qualified WFL.  */
9248           abort ();
9249
9250         TREE_CHAIN (previous) = NULL_TREE;
9251         return TREE_PURPOSE (q);
9252       }
9253 }
9254
9255 /* Resolve the expression name NAME. Return its decl.  */
9256
9257 static tree
9258 resolve_expression_name (tree id, tree *orig)
9259 {
9260   tree name = EXPR_WFL_NODE (id);
9261   tree decl;
9262
9263   /* 6.5.5.1: Simple expression names */
9264   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9265     {
9266       /* 15.13.1: NAME can appear within the scope of a local variable
9267          declaration */
9268       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9269         return decl;
9270
9271       /* 15.13.1: NAME can appear within a class declaration */
9272       else
9273         {
9274           decl = lookup_field_wrapper (current_class, name);
9275           if (decl)
9276             {
9277               tree access = NULL_TREE;
9278               int fs = FIELD_STATIC (decl);
9279
9280               /* If we're accessing an outer scope local alias, make
9281                  sure we change the name of the field we're going to
9282                  build access to. */
9283               if (FIELD_LOCAL_ALIAS_USED (decl))
9284                 name = DECL_NAME (decl);
9285
9286               check_deprecation (id, decl);
9287
9288               /* Instance variable (8.3.1.1) can't appear within
9289                  static method, static initializer or initializer for
9290                  a static variable. */
9291               if (!fs && METHOD_STATIC (current_function_decl))
9292                 {
9293                   static_ref_err (id, name, current_class);
9294                   return error_mark_node;
9295                 }
9296               /* Instance variables can't appear as an argument of
9297                  an explicit constructor invocation */
9298               if (!fs && ctxp->explicit_constructor_p
9299                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9300                 {
9301                   parse_error_context
9302                     (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9303                   return error_mark_node;
9304                 }
9305
9306               /* If we're processing an inner class and we're trying
9307                  to access a field belonging to an outer class, build
9308                  the access to the field */
9309               if (!fs && outer_field_access_p (current_class, decl))
9310                 {
9311                   if (CLASS_STATIC (TYPE_NAME (current_class)))
9312                     {
9313                       static_ref_err (id, DECL_NAME (decl), current_class);
9314                       return error_mark_node;
9315                     }
9316                   access = build_outer_field_access (id, decl);
9317                   if (orig)
9318                     *orig = access;
9319                   return access;
9320                 }
9321
9322               /* Otherwise build what it takes to access the field */
9323               access = build_field_ref ((fs ? NULL_TREE : current_this),
9324                                         DECL_CONTEXT (decl), name);
9325               if (fs)
9326                 access = maybe_build_class_init_for_field (decl, access);
9327               /* We may be asked to save the real field access node */
9328               if (orig)
9329                 *orig = access;
9330               /* Last check: can we access the field? */
9331               if (not_accessible_p (current_class, decl, NULL_TREE, 0))
9332                 {
9333                   not_accessible_field_error (id, decl);
9334                   return error_mark_node;
9335                 }
9336               /* And we return what we got */
9337               return access;
9338             }
9339           /* Fall down to error report on undefined variable */
9340         }
9341     }
9342   /* 6.5.5.2 Qualified Expression Names */
9343   else
9344     {
9345       if (orig)
9346         *orig = NULL_TREE;
9347       qualify_ambiguous_name (id);
9348       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9349       /* 15.10.2: Accessing Superclass Members using super */
9350       return resolve_field_access (id, orig, NULL);
9351     }
9352
9353   /* We've got an error here */
9354   if (INNER_CLASS_TYPE_P (current_class))
9355     parse_error_context (id,
9356                          "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9357                          IDENTIFIER_POINTER (name),
9358                          IDENTIFIER_POINTER (DECL_NAME
9359                                              (TYPE_NAME (current_class))));
9360   else
9361     parse_error_context (id, "Undefined variable `%s'",
9362                          IDENTIFIER_POINTER (name));
9363
9364   return error_mark_node;
9365 }
9366
9367 static void
9368 static_ref_err (tree wfl, tree field_id, tree class_type)
9369 {
9370   parse_error_context
9371     (wfl,
9372      "Can't make a static reference to nonstatic variable `%s' in class `%s'",
9373      IDENTIFIER_POINTER (field_id),
9374      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9375 }
9376
9377 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9378    We return something suitable to generate the field access. We also
9379    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9380    recipient's address can be null. */
9381
9382 static tree
9383 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9384 {
9385   int is_static = 0;
9386   tree field_ref;
9387   tree decl = NULL_TREE, where_found, type_found;
9388
9389   if (resolve_qualified_expression_name (qual_wfl, &decl,
9390                                          &where_found, &type_found))
9391     return error_mark_node;
9392
9393   /* Resolve the LENGTH field of an array here */
9394   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9395       && type_found && TYPE_ARRAY_P (type_found)
9396       && ! flag_emit_class_files && ! flag_emit_xref)
9397     {
9398       tree length = build_java_array_length_access (where_found);
9399       field_ref = length;
9400
9401       /* In case we're dealing with a static array, we need to
9402          initialize its class before the array length can be fetched.
9403          It's also a good time to create a DECL_RTL for the field if
9404          none already exists, otherwise if the field was declared in a
9405          class found in an external file and hasn't been (and won't
9406          be) accessed for its value, none will be created. */
9407       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9408         {
9409           build_static_field_ref (where_found);
9410           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9411         }
9412     }
9413   /* We might have been trying to resolve field.method(). In which
9414      case, the resolution is over and decl is the answer */
9415   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9416     field_ref = decl;
9417   else if (JDECL_P (decl))
9418     {
9419       if (!type_found)
9420         type_found = DECL_CONTEXT (decl);
9421       is_static = FIELD_STATIC (decl);
9422       field_ref = build_field_ref ((is_static && !flag_emit_xref?
9423                                     NULL_TREE : where_found),
9424                                    type_found, DECL_NAME (decl));
9425       if (field_ref == error_mark_node)
9426         return error_mark_node;
9427       if (is_static)
9428         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9429
9430       /* If we're looking at a static field, we may need to generate a
9431          class initialization for it.  This can happen when the access
9432          looks like `field.ref', where `field' is a static field in an
9433          interface we implement.  */
9434       if (!flag_emit_class_files
9435           && !flag_emit_xref
9436           && TREE_CODE (where_found) == VAR_DECL
9437           && FIELD_STATIC (where_found))
9438         {
9439           build_static_field_ref (where_found);
9440           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9441         }
9442     }
9443   else
9444     field_ref = decl;
9445
9446   if (field_decl)
9447     *field_decl = decl;
9448   if (field_type)
9449     *field_type = (QUAL_DECL_TYPE (decl) ?
9450                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9451   return field_ref;
9452 }
9453
9454 /* If NODE is an access to f static field, strip out the class
9455    initialization part and return the field decl, otherwise, return
9456    NODE. */
9457
9458 static tree
9459 strip_out_static_field_access_decl (tree node)
9460 {
9461   if (TREE_CODE (node) == COMPOUND_EXPR)
9462     {
9463       tree op1 = TREE_OPERAND (node, 1);
9464       if (TREE_CODE (op1) == COMPOUND_EXPR)
9465          {
9466            tree call = TREE_OPERAND (op1, 0);
9467            if (TREE_CODE (call) == CALL_EXPR
9468                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9469                && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9470                == soft_initclass_node)
9471              return TREE_OPERAND (op1, 1);
9472          }
9473       else if (JDECL_P (op1))
9474         return op1;
9475     }
9476   return node;
9477 }
9478
9479 /* 6.5.5.2: Qualified Expression Names */
9480
9481 static int
9482 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9483                                    tree *where_found, tree *type_found)
9484 {
9485   int from_type = 0;            /* Field search initiated from a type */
9486   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9487   int previous_call_static = 0;
9488   int is_static;
9489   tree decl = NULL_TREE, type = NULL_TREE, q;
9490   /* For certain for of inner class instantiation */
9491   tree saved_current, saved_this;
9492 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9493   { current_class = saved_current; current_this = saved_this;}
9494
9495   *type_found = *where_found = NULL_TREE;
9496
9497   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9498     {
9499       tree qual_wfl = QUAL_WFL (q);
9500       tree ret_decl;            /* for EH checking */
9501       int location;             /* for EH checking */
9502
9503       /* 15.10.1 Field Access Using a Primary */
9504       switch (TREE_CODE (qual_wfl))
9505         {
9506         case CALL_EXPR:
9507         case NEW_CLASS_EXPR:
9508           /* If the access to the function call is a non static field,
9509              build the code to access it. */
9510           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9511             {
9512               decl = maybe_access_field (decl, *where_found,
9513                                          DECL_CONTEXT (decl));
9514               if (decl == error_mark_node)
9515                 return 1;
9516             }
9517
9518           /* And code for the function call */
9519           if (complete_function_arguments (qual_wfl))
9520             return 1;
9521
9522           /* We might have to setup a new current class and a new this
9523              for the search of an inner class, relative to the type of
9524              a expression resolved as `decl'. The current values are
9525              saved and restored shortly after */
9526           saved_current = current_class;
9527           saved_this = current_this;
9528           if (decl
9529               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9530                   || from_qualified_this))
9531             {
9532               /* If we still have `from_qualified_this', we have the form
9533                  <T>.this.f() and we need to build <T>.this */
9534               if (from_qualified_this)
9535                 {
9536                   decl = build_access_to_thisn (current_class, type, 0);
9537                   decl = java_complete_tree (decl);
9538                   type = TREE_TYPE (TREE_TYPE (decl));
9539                 }
9540               current_class = type;
9541               current_this = decl;
9542               from_qualified_this = 0;
9543             }
9544
9545           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9546             CALL_USING_SUPER (qual_wfl) = 1;
9547           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9548                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9549           *where_found = patch_method_invocation (qual_wfl, decl, type,
9550                                                   from_super,
9551                                                   &is_static, &ret_decl);
9552           from_super = 0;
9553           if (*where_found == error_mark_node)
9554             {
9555               RESTORE_THIS_AND_CURRENT_CLASS;
9556               return 1;
9557             }
9558           *type_found = type = QUAL_DECL_TYPE (*where_found);
9559
9560           *where_found = force_evaluation_order (*where_found);
9561
9562           /* If we're creating an inner class instance, check for that
9563              an enclosing instance is in scope */
9564           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9565               && INNER_ENCLOSING_SCOPE_CHECK (type))
9566             {
9567               parse_error_context
9568                 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
9569                  lang_printable_name (type, 0),
9570                  (!current_this ? "" :
9571                   "; an explicit one must be provided when creating this inner class"));
9572               RESTORE_THIS_AND_CURRENT_CLASS;
9573               return 1;
9574             }
9575
9576           /* In case we had to change then to resolve a inner class
9577              instantiation using a primary qualified by a `new' */
9578           RESTORE_THIS_AND_CURRENT_CLASS;
9579
9580           if (location)
9581             {
9582               tree arguments = NULL_TREE;
9583               if (TREE_CODE (qual_wfl) == CALL_EXPR
9584                   && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9585                 arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9586               check_thrown_exceptions (location, ret_decl, arguments);
9587             }
9588
9589           /* If the previous call was static and this one is too,
9590              build a compound expression to hold the two (because in
9591              that case, previous function calls aren't transported as
9592              forcoming function's argument. */
9593           if (previous_call_static && is_static)
9594             {
9595               decl = build2 (COMPOUND_EXPR, TREE_TYPE (*where_found),
9596                              decl, *where_found);
9597               TREE_SIDE_EFFECTS (decl) = 1;
9598             }
9599           else
9600             {
9601               previous_call_static = is_static;
9602               decl = *where_found;
9603             }
9604           from_type = 0;
9605           continue;
9606
9607         case NEW_ARRAY_EXPR:
9608         case NEW_ANONYMOUS_ARRAY_EXPR:
9609           *where_found = decl = java_complete_tree (qual_wfl);
9610           if (decl == error_mark_node)
9611             return 1;
9612           *type_found = type = QUAL_DECL_TYPE (decl);
9613           continue;
9614
9615         case CONVERT_EXPR:
9616           *where_found = decl = java_complete_tree (qual_wfl);
9617           if (decl == error_mark_node)
9618             return 1;
9619           *type_found = type = QUAL_DECL_TYPE (decl);
9620           from_cast = 1;
9621           continue;
9622
9623         case CONDITIONAL_EXPR:
9624         case STRING_CST:
9625         case MODIFY_EXPR:
9626           *where_found = decl = java_complete_tree (qual_wfl);
9627           if (decl == error_mark_node)
9628             return 1;
9629           *type_found = type = QUAL_DECL_TYPE (decl);
9630           continue;
9631
9632         case ARRAY_REF:
9633           /* If the access to the function call is a non static field,
9634              build the code to access it. */
9635           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9636             {
9637               decl = maybe_access_field (decl, *where_found, type);
9638               if (decl == error_mark_node)
9639                 return 1;
9640             }
9641           /* And code for the array reference expression */
9642           decl = java_complete_tree (qual_wfl);
9643           if (decl == error_mark_node)
9644             return 1;
9645           type = QUAL_DECL_TYPE (decl);
9646           continue;
9647
9648         case PLUS_EXPR:
9649           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9650             return 1;
9651           if ((type = patch_string (decl)))
9652             decl = type;
9653           *where_found = QUAL_RESOLUTION (q) = decl;
9654           *type_found = type = TREE_TYPE (decl);
9655           break;
9656
9657         case CLASS_LITERAL:
9658           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9659             return 1;
9660           *where_found = QUAL_RESOLUTION (q) = decl;
9661           *type_found = type = TREE_TYPE (decl);
9662           break;
9663
9664         default:
9665           /* Fix for -Wall Just go to the next statement. Don't
9666              continue */
9667           break;
9668         }
9669
9670       /* If we fall here, we weren't processing a (static) function call. */
9671       previous_call_static = 0;
9672
9673       /* It can be the keyword THIS */
9674       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9675           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9676         {
9677           if (!current_this)
9678             {
9679               parse_error_context
9680                 (wfl, "Keyword `this' used outside allowed context");
9681               return 1;
9682             }
9683           if (ctxp->explicit_constructor_p
9684               && type == current_class)
9685             {
9686               parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9687               return 1;
9688             }
9689           /* We have to generate code for intermediate access */
9690           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9691             {
9692               *where_found = decl = current_this;
9693               *type_found = type = QUAL_DECL_TYPE (decl);
9694             }
9695           /* We're trying to access the this from somewhere else. Make sure
9696              it's allowed before doing so. */
9697           else
9698             {
9699               if (!enclosing_context_p (type, current_class))
9700                 {
9701                   char *p  = xstrdup (lang_printable_name (type, 0));
9702                   parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9703                                        p, p,
9704                                        lang_printable_name (current_class, 0));
9705                   free (p);
9706                   return 1;
9707                 }
9708               from_qualified_this = 1;
9709               /* If there's nothing else after that, we need to
9710                  produce something now, otherwise, the section of the
9711                  code that needs to produce <T>.this will generate
9712                  what is necessary. */
9713               if (!TREE_CHAIN (q))
9714                 {
9715                   decl = build_access_to_thisn (current_class, type, 0);
9716                   *where_found = decl = java_complete_tree (decl);
9717                   *type_found = type = TREE_TYPE (decl);
9718                 }
9719             }
9720
9721           from_type = 0;
9722           continue;
9723         }
9724
9725       /* 15.10.2 Accessing Superclass Members using SUPER */
9726       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9727           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9728         {
9729           tree node;
9730           /* Check on the restricted use of SUPER */
9731           if (METHOD_STATIC (current_function_decl)
9732               || current_class == object_type_node)
9733             {
9734               parse_error_context
9735                 (wfl, "Keyword `super' used outside allowed context");
9736               return 1;
9737             }
9738           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9739           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9740                              CLASSTYPE_SUPER (current_class),
9741                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9742           *where_found = decl = java_complete_tree (node);
9743           if (decl == error_mark_node)
9744             return 1;
9745           *type_found = type = QUAL_DECL_TYPE (decl);
9746           from_super = from_type = 1;
9747           continue;
9748         }
9749
9750       /* 15.13.1: Can't search for field name in packages, so we
9751          assume a variable/class name was meant. */
9752       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9753         {
9754           tree name;
9755           if ((decl = resolve_package (wfl, &q, &name)))
9756             {
9757               tree list;
9758               *where_found = decl;
9759
9760               check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
9761
9762               /* We want to be absolutely sure that the class is laid
9763                  out. We're going to search something inside it. */
9764               *type_found = type = TREE_TYPE (decl);
9765               layout_class (type);
9766               from_type = 1;
9767
9768               /* Fix them all the way down, if any are left. */
9769               if (q)
9770                 {
9771                   list = TREE_CHAIN (q);
9772                   while (list)
9773                     {
9774                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9775                       list = TREE_CHAIN (list);
9776                     }
9777                 }
9778             }
9779           else
9780             {
9781               if (from_super || from_cast)
9782                 parse_error_context
9783                   ((from_cast ? qual_wfl : wfl),
9784                    "No variable `%s' defined in class `%s'",
9785                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9786                    lang_printable_name (type, 0));
9787               else
9788                 parse_error_context
9789                   (qual_wfl, "Undefined variable or class name: `%s'",
9790                    IDENTIFIER_POINTER (name));
9791               return 1;
9792             }
9793         }
9794
9795       /* We have a type name. It's been already resolved when the
9796          expression was qualified. */
9797       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9798         {
9799           decl = QUAL_RESOLUTION (q);
9800
9801           /* Sneak preview. If next we see a `new', we're facing a
9802              qualification which resulted in a type being selected
9803              instead of a field.  Report the error.  */
9804           if(TREE_CHAIN (q)
9805              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9806             {
9807               parse_error_context (qual_wfl, "Undefined variable `%s'",
9808                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9809               return 1;
9810             }
9811
9812           check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
9813
9814           check_deprecation (qual_wfl, decl);
9815
9816           type = TREE_TYPE (decl);
9817           from_type = 1;
9818         }
9819       /* We resolve an expression name */
9820       else
9821         {
9822           tree field_decl = NULL_TREE;
9823
9824           /* If there exists an early resolution, use it. That occurs
9825              only once and we know that there are more things to
9826              come. Don't do that when processing something after SUPER
9827              (we need more thing to be put in place below */
9828           if (!from_super && QUAL_RESOLUTION (q))
9829             {
9830               decl = QUAL_RESOLUTION (q);
9831               if (!type)
9832                 {
9833                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9834                     {
9835                       if (current_this)
9836                         *where_found = current_this;
9837                       else
9838                         {
9839                           static_ref_err (qual_wfl, DECL_NAME (decl),
9840                                           current_class);
9841                           return 1;
9842                         }
9843                       if (outer_field_access_p (current_class, decl))
9844                         decl = build_outer_field_access (qual_wfl, decl);
9845                     }
9846                   else
9847                     {
9848                       *where_found = TREE_TYPE (decl);
9849                       if (TREE_CODE (*where_found) == POINTER_TYPE)
9850                         *where_found = TREE_TYPE (*where_found);
9851                     }
9852                 }
9853             }
9854
9855           /* Report and error if we're using a numerical literal as a
9856              qualifier. It can only be an INTEGER_CST. */
9857           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9858             {
9859               parse_error_context
9860                 (wfl, "Can't use type `%s' as a qualifier",
9861                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
9862               return 1;
9863             }
9864
9865           /* We have to search for a field, knowing the type of its
9866              container. The flag FROM_TYPE indicates that we resolved
9867              the last member of the expression as a type name, which
9868              means that for the resolution of this field, we'll look
9869              for other errors than if it was resolved as a member of
9870              an other field. */
9871           else
9872             {
9873               int is_static;
9874               tree field_decl_type; /* For layout */
9875
9876               if (!from_type && !JREFERENCE_TYPE_P (type))
9877                 {
9878                   parse_error_context
9879                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9880                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9881                      lang_printable_name (type, 0),
9882                      IDENTIFIER_POINTER (DECL_NAME (decl)));
9883                   return 1;
9884                 }
9885
9886               field_decl = lookup_field_wrapper (type,
9887                                                  EXPR_WFL_NODE (qual_wfl));
9888
9889               /* Maybe what we're trying to access to is an inner
9890                  class, only if decl is a TYPE_DECL. */
9891               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9892                 {
9893                   tree ptr, inner_decl;
9894
9895                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9896                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9897                   if (inner_decl)
9898                     {
9899                       check_inner_class_access (inner_decl, decl, qual_wfl);
9900                       type = TREE_TYPE (inner_decl);
9901                       decl = inner_decl;
9902                       from_type = 1;
9903                       continue;
9904                     }
9905                 }
9906
9907               if (field_decl == NULL_TREE)
9908                 {
9909                   parse_error_context
9910                     (qual_wfl, "No variable `%s' defined in type `%s'",
9911                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9912                      GET_TYPE_NAME (type));
9913                   return 1;
9914                 }
9915               if (field_decl == error_mark_node)
9916                 return 1;
9917
9918               /* Layout the type of field_decl, since we may need
9919                  it. Don't do primitive types or loaded classes. The
9920                  situation of non primitive arrays may not handled
9921                  properly here. FIXME */
9922               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9923                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9924               else
9925                 field_decl_type = TREE_TYPE (field_decl);
9926               if (!JPRIMITIVE_TYPE_P (field_decl_type)
9927                   && !CLASS_LOADED_P (field_decl_type)
9928                   && !TYPE_ARRAY_P (field_decl_type))
9929                 resolve_and_layout (field_decl_type, NULL_TREE);
9930
9931               /* Check on accessibility here */
9932               if (not_accessible_p (current_class, field_decl,
9933                                     *type_found, from_super))
9934                 return not_accessible_field_error (qual_wfl,field_decl);
9935               check_deprecation (qual_wfl, field_decl);
9936
9937               /* There are things to check when fields are accessed
9938                  from type. There are no restrictions on a static
9939                  declaration of the field when it is accessed from an
9940                  interface */
9941               is_static = FIELD_STATIC (field_decl);
9942               if (!from_super && from_type
9943                   && !TYPE_INTERFACE_P (type)
9944                   && !is_static
9945                   && (current_function_decl
9946                       && METHOD_STATIC (current_function_decl)))
9947                 {
9948                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
9949                   return 1;
9950                 }
9951               from_cast = from_super = 0;
9952
9953               /* It's an access from a type but it isn't static, we
9954                  make it relative to `this'. */
9955               if (!is_static && from_type)
9956                 decl = current_this;
9957
9958               /* If we need to generate something to get a proper
9959                  handle on what this field is accessed from, do it
9960                  now. */
9961               if (!is_static)
9962                 {
9963                   decl = maybe_access_field (decl, *where_found, *type_found);
9964                   if (decl == error_mark_node)
9965                     return 1;
9966                 }
9967
9968               /* We want to keep the location were found it, and the type
9969                  we found. */
9970               *where_found = decl;
9971               *type_found = type;
9972
9973               /* Generate the correct expression for field access from
9974                  qualified this */
9975               if (from_qualified_this)
9976                 {
9977                   field_decl = build_outer_field_access (qual_wfl, field_decl);
9978                   from_qualified_this = 0;
9979                 }
9980
9981               /* This is the decl found and eventually the next one to
9982                  search from */
9983               decl = field_decl;
9984             }
9985           from_type = 0;
9986           type = QUAL_DECL_TYPE (decl);
9987
9988           /* Sneak preview. If decl is qualified by a `new', report
9989              the error here to be accurate on the peculiar construct */
9990           if (TREE_CHAIN (q)
9991               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
9992               && !JREFERENCE_TYPE_P (type))
9993             {
9994               parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
9995                                    lang_printable_name (type, 0));
9996               return 1;
9997             }
9998         }
9999       /* `q' might have changed due to a after package resolution
10000          re-qualification */
10001       if (!q)
10002         break;
10003     }
10004   *found_decl = decl;
10005   return 0;
10006 }
10007
10008 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10009    can't be accessed from REFERENCE (a record type). If MEMBER
10010    features a protected access, we then use WHERE which, if non null,
10011    holds the type of MEMBER's access that is checked against
10012    6.6.2.1. This function should be used when decl is a field or a
10013    method.  */
10014
10015 static int
10016 not_accessible_p (tree reference, tree member, tree where, int from_super)
10017 {
10018   int access_flag = get_access_flags_from_decl (member);
10019   bool is_static = false;
10020
10021   if (TREE_CODE (member) == FIELD_DECL ||
10022       TREE_CODE (member) == VAR_DECL)
10023     is_static = FIELD_STATIC (member);
10024   else
10025     is_static = METHOD_STATIC (member);
10026
10027   /* Access always granted for members declared public */
10028   if (access_flag & ACC_PUBLIC)
10029     return 0;
10030
10031   /* Check access on protected members */
10032   if (access_flag & ACC_PROTECTED)
10033     {
10034       /* Access granted if it occurs from within the package
10035          containing the class in which the protected member is
10036          declared */
10037       if (class_in_current_package (DECL_CONTEXT (member)))
10038         return 0;
10039
10040       /* If accessed with the form `super.member', then access is granted */
10041       if (from_super)
10042         return 0;
10043
10044       /* If WHERE is active, access was made through a qualifier. For
10045          non-static members, access is granted if the type of the qualifier
10046          is or is a sublass of the type the access is made from (6.6.2.1.)  */
10047       if (where && !is_static)
10048         {
10049           while (reference)
10050             {
10051               if (inherits_from_p (where, reference))
10052                 return 0;
10053               if (PURE_INNER_CLASS_TYPE_P (reference))
10054                 reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10055               else
10056                 break;
10057             }
10058           return 1;
10059         }
10060
10061       /* Otherwise, access is granted if occurring from within the class
10062          where member is declared, or a subclass of it.  */
10063       while (reference)
10064         {
10065           if (inherits_from_p (reference, DECL_CONTEXT (member)))
10066             return 0;
10067           if (PURE_INNER_CLASS_TYPE_P (reference))
10068             reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10069           else
10070             break;
10071         }
10072       return 1;
10073     }
10074
10075   /* Check access on private members. Access is granted only if it
10076      occurs from within the class in which it is declared -- that does
10077      it for innerclasses too. */
10078   if (access_flag & ACC_PRIVATE)
10079     {
10080       if (reference == DECL_CONTEXT (member) ||
10081           common_enclosing_context_p (DECL_CONTEXT (member), reference))
10082         return 0;
10083       return 1;
10084     }
10085
10086   /* Default access is permitted only when occurring from within the
10087      package in which the context (MEMBER) is declared.  */
10088   return !class_in_current_package (DECL_CONTEXT (member));
10089 }
10090
10091 /* Test deprecated decl access.  */
10092 static void
10093 check_deprecation (tree wfl, tree decl)
10094 {
10095   const char *file;
10096   tree elt;
10097
10098   if (! flag_deprecated)
10099     return;
10100
10101   /* We want to look at the element type of arrays here, so we strip
10102      all surrounding array types.  */
10103   if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10104     {
10105       elt = TREE_TYPE (decl);
10106       while (TYPE_ARRAY_P (elt))
10107         elt = TYPE_ARRAY_ELEMENT (elt);
10108       /* We'll end up with a pointer type, so we use TREE_TYPE to go
10109          to the record.  */
10110       decl = TYPE_NAME (TREE_TYPE (elt));
10111     }
10112   file = DECL_SOURCE_FILE (decl);
10113
10114   /* Complain if the field is deprecated and the file it was defined
10115      in isn't compiled at the same time the file which contains its
10116      use is */
10117   if (DECL_DEPRECATED (decl)
10118       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10119     {
10120       const char *the;
10121       switch (TREE_CODE (decl))
10122         {
10123         case FUNCTION_DECL:
10124           the = "method";
10125           break;
10126         case FIELD_DECL:
10127         case VAR_DECL:
10128           the = "field";
10129           break;
10130         case TYPE_DECL:
10131           parse_warning_context (wfl, "The class `%s' has been deprecated",
10132                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10133           return;
10134         default:
10135           abort ();
10136         }
10137       /* Don't issue a message if the context as been deprecated as a
10138          whole. */
10139       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10140         parse_warning_context
10141           (wfl, "The %s `%s' in class `%s' has been deprecated",
10142            the, lang_printable_name (decl, 0),
10143            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10144     }
10145 }
10146
10147 /* Returns 1 if class was declared in the current package, 0 otherwise */
10148
10149 static GTY(()) tree cicp_cache;
10150 static int
10151 class_in_current_package (tree class)
10152 {
10153   int qualified_flag;
10154   tree left;
10155
10156   if (cicp_cache == class)
10157     return 1;
10158
10159   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10160
10161   /* If the current package is empty and the name of CLASS is
10162      qualified, class isn't in the current package.  If there is a
10163      current package and the name of the CLASS is not qualified, class
10164      isn't in the current package */
10165   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10166     return 0;
10167
10168   /* If there is not package and the name of CLASS isn't qualified,
10169      they belong to the same unnamed package */
10170   if (!ctxp->package && !qualified_flag)
10171     return 1;
10172
10173   /* Compare the left part of the name of CLASS with the package name */
10174   split_qualified_name (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10175   if (ctxp->package == left)
10176     {
10177       cicp_cache = class;
10178       return 1;
10179     }
10180   return 0;
10181 }
10182
10183 /* This function may generate code to access DECL from WHERE. This is
10184    done only if certain conditions meet.  */
10185
10186 static tree
10187 maybe_access_field (tree decl, tree where, tree type)
10188 {
10189   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10190       && !FIELD_STATIC (decl))
10191     decl = build_field_ref (where ? where : current_this,
10192                             (type ? type : DECL_CONTEXT (decl)),
10193                             DECL_NAME (decl));
10194   return decl;
10195 }
10196
10197 /* Build a method invocation, by patching PATCH. If non NULL
10198    and according to the situation, PRIMARY and WHERE may be
10199    used. IS_STATIC is set to 1 if the invoked function is static. */
10200
10201 static tree
10202 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10203                          int *is_static, tree *ret_decl)
10204 {
10205   tree wfl = TREE_OPERAND (patch, 0);
10206   tree args = TREE_OPERAND (patch, 1);
10207   tree name = EXPR_WFL_NODE (wfl);
10208   tree list;
10209   int is_static_flag = 0;
10210   int is_super_init = 0;
10211   tree this_arg = NULL_TREE;
10212   int is_array_clone_call = 0;
10213
10214   /* Should be overridden if everything goes well. Otherwise, if
10215      something fails, it should keep this value. It stop the
10216      evaluation of a bogus assignment. See java_complete_tree,
10217      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10218      evaluating an assignment */
10219   TREE_TYPE (patch) = error_mark_node;
10220
10221   /* Since lookup functions are messing with line numbers, save the
10222      context now.  */
10223   java_parser_context_save_global ();
10224
10225   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10226
10227   /* Resolution of qualified name, excluding constructors */
10228   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10229     {
10230       tree identifier, identifier_wfl, type, resolved;
10231       /* Extract the last IDENTIFIER of the qualified
10232          expression. This is a wfl and we will use it's location
10233          data during error report. */
10234       identifier_wfl = cut_identifier_in_qualified (wfl);
10235       identifier = EXPR_WFL_NODE (identifier_wfl);
10236
10237       /* Given the context, IDENTIFIER is syntactically qualified
10238          as a MethodName. We need to qualify what's before */
10239       qualify_ambiguous_name (wfl);
10240       resolved = resolve_field_access (wfl, NULL, NULL);
10241
10242       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10243          && FIELD_FINAL (resolved)
10244          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10245          && !flag_emit_class_files && !flag_emit_xref)
10246        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10247
10248       if (resolved == error_mark_node)
10249         PATCH_METHOD_RETURN_ERROR ();
10250
10251       type = GET_SKIP_TYPE (resolved);
10252       resolve_and_layout (type, NULL_TREE);
10253
10254       if (JPRIMITIVE_TYPE_P (type))
10255         {
10256           parse_error_context
10257             (identifier_wfl,
10258              "Can't invoke a method on primitive type `%s'",
10259              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10260           PATCH_METHOD_RETURN_ERROR ();
10261         }
10262
10263       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10264       args = nreverse (args);
10265
10266       /* We're resolving a call from a type */
10267       if (TREE_CODE (resolved) == TYPE_DECL)
10268         {
10269           if (CLASS_INTERFACE (resolved))
10270             {
10271               parse_error_context
10272                 (identifier_wfl,
10273                 "Can't make static reference to method `%s' in interface `%s'",
10274                  IDENTIFIER_POINTER (identifier),
10275                  IDENTIFIER_POINTER (name));
10276               PATCH_METHOD_RETURN_ERROR ();
10277             }
10278           if (list && !METHOD_STATIC (list))
10279             {
10280               char *fct_name = xstrdup (lang_printable_name (list, 0));
10281               parse_error_context
10282                 (identifier_wfl,
10283                  "Can't make static reference to method `%s %s' in class `%s'",
10284                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10285                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10286               free (fct_name);
10287               PATCH_METHOD_RETURN_ERROR ();
10288             }
10289         }
10290       else
10291         this_arg = primary = resolved;
10292
10293       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10294         is_array_clone_call = 1;
10295
10296       /* IDENTIFIER_WFL will be used to report any problem further */
10297       wfl = identifier_wfl;
10298     }
10299   /* Resolution of simple names, names generated after a primary: or
10300      constructors */
10301   else
10302     {
10303       tree class_to_search = NULL_TREE;
10304       int lc;                   /* Looking for Constructor */
10305
10306       /* We search constructor in their target class */
10307       if (CALL_CONSTRUCTOR_P (patch))
10308         {
10309           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10310             class_to_search = EXPR_WFL_NODE (wfl);
10311           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10312                    this_identifier_node)
10313             class_to_search = NULL_TREE;
10314           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10315                    super_identifier_node)
10316             {
10317               is_super_init = 1;
10318               if (CLASSTYPE_SUPER (current_class))
10319                 class_to_search =
10320                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10321               else
10322                 {
10323                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10324                   PATCH_METHOD_RETURN_ERROR ();
10325                 }
10326             }
10327
10328           /* Class to search is NULL if we're searching the current one */
10329           if (class_to_search)
10330             {
10331               class_to_search = resolve_and_layout (class_to_search, wfl);
10332
10333               if (!class_to_search)
10334                 {
10335                   parse_error_context
10336                     (wfl, "Class `%s' not found in type declaration",
10337                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10338                   PATCH_METHOD_RETURN_ERROR ();
10339                 }
10340
10341               /* Can't instantiate an abstract class, but we can
10342                  invoke it's constructor. It's use within the `new'
10343                  context is denied here. */
10344               if (CLASS_ABSTRACT (class_to_search)
10345                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10346                 {
10347                   parse_error_context
10348                     (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10349                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10350                   PATCH_METHOD_RETURN_ERROR ();
10351                 }
10352
10353               class_to_search = TREE_TYPE (class_to_search);
10354             }
10355           else
10356             class_to_search = current_class;
10357           lc = 1;
10358         }
10359       /* This is a regular search in the local class, unless an
10360          alternate class is specified. */
10361       else
10362         {
10363           if (where != NULL_TREE)
10364             class_to_search = where;
10365           else if (QUALIFIED_P (name))
10366             class_to_search = current_class;
10367           else
10368             {
10369               class_to_search = current_class;
10370
10371               for (;;)
10372                 {
10373                   if (has_method (class_to_search, name))
10374                     break;
10375                   if (! INNER_CLASS_TYPE_P (class_to_search))
10376                     {
10377                       parse_error_context (wfl,
10378                                            "No method named `%s' in scope",
10379                                            IDENTIFIER_POINTER (name));
10380                       PATCH_METHOD_RETURN_ERROR ();
10381                     }
10382                   class_to_search
10383                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10384                 }
10385             }
10386           lc = 0;
10387         }
10388
10389       /* NAME is a simple identifier or comes from a primary. Search
10390          in the class whose declaration contain the method being
10391          invoked. */
10392       resolve_and_layout (class_to_search, NULL_TREE);
10393
10394       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10395       /* Don't continue if no method were found, as the next statement
10396          can't be executed then. */
10397       if (!list)
10398         PATCH_METHOD_RETURN_ERROR ();
10399
10400       if (TYPE_ARRAY_P (class_to_search)
10401           && DECL_NAME (list) == get_identifier ("clone"))
10402         is_array_clone_call = 1;
10403
10404       /* Check for static reference if non static methods */
10405       if (check_for_static_method_reference (wfl, patch, list,
10406                                              class_to_search, primary))
10407         PATCH_METHOD_RETURN_ERROR ();
10408
10409       /* Check for inner classes creation from illegal contexts */
10410       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10411                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10412           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10413           && !DECL_INIT_P (current_function_decl))
10414         {
10415           parse_error_context
10416             (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10417              lang_printable_name (class_to_search, 0),
10418              (!current_this ? "" :
10419               "; an explicit one must be provided when creating this inner class"));
10420           PATCH_METHOD_RETURN_ERROR ();
10421         }
10422
10423       /* Non static methods are called with the current object extra
10424          argument. If patch a `new TYPE()', the argument is the value
10425          returned by the object allocator. If method is resolved as a
10426          primary, use the primary otherwise use the current THIS. */
10427       args = nreverse (args);
10428       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10429         {
10430           this_arg = primary ? primary : current_this;
10431
10432           /* If we're using an access method, things are different.
10433              There are two family of cases:
10434
10435              1) We're not generating bytecodes:
10436
10437              - LIST is non static. It's invocation is transformed from
10438                x(a1,...,an) into this$<n>.x(a1,....an).
10439              - LIST is static. It's invocation is transformed from
10440                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10441
10442              2) We're generating bytecodes:
10443
10444              - LIST is non static. It's invocation is transformed from
10445                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10446              - LIST is static. It's invocation is transformed from
10447                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10448
10449              Of course, this$<n> can be arbitrarily complex, ranging from
10450              this$0 (the immediate outer context) to
10451              access$0(access$0(...(this$0))).
10452
10453              maybe_use_access_method returns a nonzero value if the
10454              this_arg has to be moved into the (then generated) stub
10455              argument list. In the meantime, the selected function
10456              might have be replaced by a generated stub. */
10457           if (!primary &&
10458               maybe_use_access_method (is_super_init, &list, &this_arg))
10459             {
10460               args = tree_cons (NULL_TREE, this_arg, args);
10461               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10462             }
10463         }
10464     }
10465
10466   /* Merge point of all resolution schemes. If we have nothing, this
10467      is an error, already signaled */
10468   if (!list)
10469     PATCH_METHOD_RETURN_ERROR ();
10470
10471   /* Check accessibility, position the is_static flag, build and
10472      return the call */
10473   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10474                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10475                          NULL_TREE), from_super)
10476       /* Calls to clone() on array types are permitted as a special-case. */
10477       && !is_array_clone_call)
10478     {
10479       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10480       const char *const access =
10481         accessibility_string (get_access_flags_from_decl (list));
10482       const char *const klass =
10483         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10484       const char *const refklass =
10485         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10486       const char *const what = (DECL_CONSTRUCTOR_P (list)
10487                                 ? "constructor" : "method");
10488       parse_error_context (wfl,
10489                            "Can't access %s %s `%s.%s' from `%s'",
10490                            access, what, klass, fct_name, refklass);
10491       PATCH_METHOD_RETURN_ERROR ();
10492     }
10493
10494   /* Deprecation check: check whether the method being invoked or the
10495      instance-being-created's type are deprecated.  */
10496   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10497     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10498   check_deprecation (wfl, list);
10499
10500   /* If invoking a innerclass constructor, there are hidden parameters
10501      to pass */
10502   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10503       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10504     {
10505       /* And make sure we add the accessed local variables to be saved
10506          in field aliases. */
10507       args = build_alias_initializer_parameter_list
10508         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10509
10510       /* Secretly pass the current_this/primary as a second argument */
10511       if (primary || current_this)
10512         {
10513           tree extra_arg;
10514           tree this_type = (current_this ?
10515                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10516           /* Method's (list) enclosing context */
10517           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10518           /* If we have a primary, use it. */
10519           if (primary)
10520             extra_arg = primary;
10521           /* The current `this' is an inner class but isn't a direct
10522              enclosing context for the inner class we're trying to
10523              create. Build an access to the proper enclosing context
10524              and use it. */
10525           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10526                    && this_type != TREE_TYPE (mec))
10527             {
10528
10529               extra_arg = build_access_to_thisn (current_class,
10530                                                  TREE_TYPE (mec), 0);
10531               extra_arg = java_complete_tree (extra_arg);
10532             }
10533           /* Otherwise, just use the current `this' as an enclosing
10534              context. */
10535           else
10536             extra_arg = current_this;
10537           args = tree_cons (NULL_TREE, extra_arg, args);
10538         }
10539       else
10540         args = tree_cons (NULL_TREE, integer_zero_node, args);
10541     }
10542
10543   /* This handles the situation where a constructor invocation needs
10544      to have an enclosing context passed as a second parameter (the
10545      constructor is one of an inner class). */
10546   if ((is_super_init ||
10547        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10548       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10549     {
10550       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10551       tree extra_arg =
10552         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10553       extra_arg = java_complete_tree (extra_arg);
10554       args = tree_cons (NULL_TREE, extra_arg, args);
10555     }
10556
10557   is_static_flag = METHOD_STATIC (list);
10558   if (! is_static_flag && this_arg != NULL_TREE)
10559     args = tree_cons (NULL_TREE, this_arg, args);
10560
10561   /* In the context of an explicit constructor invocation, we can't
10562      invoke any method relying on `this'. Exceptions are: we're
10563      invoking a static function, primary exists and is not the current
10564      this, we're creating a new object. */
10565   if (ctxp->explicit_constructor_p
10566       && !is_static_flag
10567       && (!primary || primary == current_this)
10568       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10569     {
10570       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10571       PATCH_METHOD_RETURN_ERROR ();
10572     }
10573   java_parser_context_restore_global ();
10574   if (is_static)
10575     *is_static = is_static_flag;
10576   /* Sometimes, we want the decl of the selected method. Such as for
10577      EH checking */
10578   if (ret_decl)
10579     *ret_decl = list;
10580   patch = patch_invoke (patch, list, args);
10581
10582   /* Now is a good time to insert the call to finit$ */
10583   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10584     {
10585       tree finit_parms, finit_call;
10586
10587       /* Prepare to pass hidden parameters to finit$, if any. */
10588       finit_parms = build_alias_initializer_parameter_list
10589         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10590
10591       finit_call =
10592         build_method_invocation (build_wfl_node (finit_identifier_node),
10593                                  finit_parms);
10594
10595       /* Generate the code used to initialize fields declared with an
10596          initialization statement and build a compound statement along
10597          with the super constructor invocation. */
10598       CAN_COMPLETE_NORMALLY (patch) = 1;
10599       patch = build2 (COMPOUND_EXPR, void_type_node, patch,
10600                       java_complete_tree (finit_call));
10601     }
10602   return patch;
10603 }
10604
10605 /* Check that we're not trying to do a static reference to a method in
10606    non static method. Return 1 if it's the case, 0 otherwise. */
10607
10608 static int
10609 check_for_static_method_reference (tree wfl, tree node, tree method,
10610                                    tree where, tree primary)
10611 {
10612   if (METHOD_STATIC (current_function_decl)
10613       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10614     {
10615       char *fct_name = xstrdup (lang_printable_name (method, 0));
10616       parse_error_context
10617         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10618          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10619          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10620       free (fct_name);
10621       return 1;
10622     }
10623   return 0;
10624 }
10625
10626 /* Fix the invocation of *MDECL if necessary in the case of a
10627    invocation from an inner class. *THIS_ARG might be modified
10628    appropriately and an alternative access to *MDECL might be
10629    returned.  */
10630
10631 static int
10632 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10633 {
10634   tree ctx;
10635   tree md = *mdecl, ta = *this_arg;
10636   int to_return = 0;
10637   int non_static_context = !METHOD_STATIC (md);
10638
10639   if (is_super_init
10640       || DECL_CONTEXT (md) == current_class
10641       || !PURE_INNER_CLASS_TYPE_P (current_class)
10642       || DECL_FINIT_P (md)
10643       || DECL_INSTINIT_P (md))
10644     return 0;
10645
10646   /* If we're calling a method found in an enclosing class, generate
10647      what it takes to retrieve the right this. Don't do that if we're
10648      invoking a static method. Note that if MD's type is unrelated to
10649      CURRENT_CLASS, then the current this can be used. */
10650
10651   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10652     {
10653       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10654       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10655         {
10656           ta = build_current_thisn (current_class);
10657           ta = build_wfl_node (ta);
10658         }
10659       else
10660         {
10661           tree type = ctx;
10662           while (type)
10663             {
10664               maybe_build_thisn_access_method (type);
10665               if (inherits_from_p (type, DECL_CONTEXT (md)))
10666                 {
10667                   ta = build_access_to_thisn (ctx, type, 0);
10668                   break;
10669                 }
10670               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10671                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10672             }
10673         }
10674       ta = java_complete_tree (ta);
10675     }
10676
10677   /* We might have to use an access method to get to MD. We can
10678      break the method access rule as far as we're not generating
10679      bytecode */
10680   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10681     {
10682       md = build_outer_method_access_method (md);
10683       to_return = 1;
10684     }
10685
10686   *mdecl = md;
10687   *this_arg = ta;
10688
10689   /* Returning a nonzero value indicates we were doing a non static
10690      method invocation that is now a static invocation. It will have
10691      callee displace `this' to insert it in the regular argument
10692      list. */
10693   return (non_static_context && to_return);
10694 }
10695
10696 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10697    mode.  */
10698
10699 static tree
10700 patch_invoke (tree patch, tree method, tree args)
10701 {
10702   tree dtable, func;
10703   tree original_call, t, ta;
10704   tree check = NULL_TREE;
10705
10706   /* Last step for args: convert build-in types. If we're dealing with
10707      a new TYPE() type call, the first argument to the constructor
10708      isn't found in the incoming argument list, but delivered by
10709      `new' */
10710   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10711   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10712     t = TREE_CHAIN (t);
10713   for (ta = args; t != end_params_node && ta;
10714        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10715     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10716         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10717       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10718
10719   /* Resolve unresolved returned type issues */
10720   t = TREE_TYPE (TREE_TYPE (method));
10721   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10722     resolve_and_layout (TREE_TYPE (t), NULL);
10723
10724   if (flag_emit_class_files || flag_emit_xref)
10725     func = method;
10726   else
10727     {
10728       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10729         {
10730         case INVOKE_VIRTUAL:
10731           dtable = invoke_build_dtable (0, args);
10732           func = build_invokevirtual (dtable, method);
10733           break;
10734
10735         case INVOKE_NONVIRTUAL:
10736           /* If the object for the method call is null, we throw an
10737              exception.  We don't do this if the object is the current
10738              method's `this'.  In other cases we just rely on an
10739              optimization pass to eliminate redundant checks.  */
10740           if (TREE_VALUE (args) != current_this)
10741             {
10742               /* We use a save_expr here to make sure we only evaluate
10743                  the new `self' expression once.  */
10744               tree save_arg = save_expr (TREE_VALUE (args));
10745               TREE_VALUE (args) = save_arg;
10746               check = java_check_reference (save_arg, 1);
10747             }
10748           /* Fall through.  */
10749
10750         case INVOKE_SUPER:
10751         case INVOKE_STATIC:
10752           {
10753             tree signature = build_java_signature (TREE_TYPE (method));
10754             func = build_known_method_ref (method, TREE_TYPE (method),
10755                                            DECL_CONTEXT (method),
10756                                            signature, args);
10757           }
10758           break;
10759
10760         case INVOKE_INTERFACE:
10761           dtable = invoke_build_dtable (1, args);
10762           func = build_invokeinterface (dtable, method);
10763           break;
10764
10765         default:
10766           abort ();
10767         }
10768
10769       /* Ensure self_type is initialized, (invokestatic). FIXME */
10770       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10771     }
10772
10773   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10774   TREE_OPERAND (patch, 0) = func;
10775   TREE_OPERAND (patch, 1) = args;
10776   patch = check_for_builtin (method, patch);
10777   original_call = patch;
10778
10779   /* We're processing a `new TYPE ()' form. New is called and its
10780      returned value is the first argument to the constructor. We build
10781      a COMPOUND_EXPR and use saved expression so that the overall NEW
10782      expression value is a pointer to a newly created and initialized
10783      class. */
10784   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10785     {
10786       tree class = DECL_CONTEXT (method);
10787       tree c1, saved_new, size, new;
10788       tree alloc_node;
10789
10790       if (flag_emit_class_files || flag_emit_xref)
10791         {
10792           TREE_TYPE (patch) = build_pointer_type (class);
10793           return patch;
10794         }
10795       if (!TYPE_SIZE (class))
10796         safe_layout_class (class);
10797       size = size_in_bytes (class);
10798       alloc_node =
10799         (class_has_finalize_method (class) ? alloc_object_node
10800                                            : alloc_no_finalizer_node);
10801       new = build3 (CALL_EXPR, promote_type (class),
10802                     build_address_of (alloc_node),
10803                     build_tree_list (NULL_TREE, build_class_ref (class)),
10804                     NULL_TREE);
10805       saved_new = save_expr (new);
10806       c1 = build_tree_list (NULL_TREE, saved_new);
10807       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10808       TREE_OPERAND (original_call, 1) = c1;
10809       TREE_SET_CODE (original_call, CALL_EXPR);
10810       patch = build2 (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10811     }
10812
10813   /* If CHECK is set, then we are building a check to see if the object
10814      is NULL.  */
10815   if (check != NULL_TREE)
10816     {
10817       /* We have to call force_evaluation_order now because creating a
10818          COMPOUND_EXPR wraps the arg list in a way that makes it
10819          unrecognizable by force_evaluation_order later.  Yuk.  */
10820       patch = build2 (COMPOUND_EXPR, TREE_TYPE (patch), check,
10821                       force_evaluation_order (patch));
10822       TREE_SIDE_EFFECTS (patch) = 1;
10823     }
10824
10825   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10826      put it as the first expression of a COMPOUND_EXPR. The second
10827      expression being an empty statement to be later patched if
10828      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10829      the VALUE is the compound) in a hashtable and return a
10830      COMPOUND_EXPR built so that the result of the evaluation of the
10831      original PATCH node is returned. */
10832   if (STATIC_CLASS_INIT_OPT_P ()
10833       && current_function_decl && METHOD_STATIC (method))
10834     {
10835       tree list;
10836       tree fndecl = current_function_decl;
10837       /* We have to call force_evaluation_order now because creating a
10838          COMPOUND_EXPR wraps the arg list in a way that makes it
10839          unrecognizable by force_evaluation_order later.  Yuk.  */
10840       tree save = force_evaluation_order (patch);
10841       tree type = TREE_TYPE (patch);
10842
10843       patch = build2 (COMPOUND_EXPR, type, save, build_java_empty_stmt ());
10844       list = tree_cons (method, patch,
10845                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10846
10847       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10848
10849       patch = build2 (COMPOUND_EXPR, type, patch, save);
10850     }
10851
10852   return patch;
10853 }
10854
10855 static int
10856 invocation_mode (tree method, int super)
10857 {
10858   int access = get_access_flags_from_decl (method);
10859
10860   if (super)
10861     return INVOKE_SUPER;
10862
10863   if (access & ACC_STATIC)
10864     return INVOKE_STATIC;
10865
10866   /* We have to look for a constructor before we handle nonvirtual
10867      calls; otherwise the constructor will look nonvirtual.  */
10868   if (DECL_CONSTRUCTOR_P (method))
10869     return INVOKE_STATIC;
10870
10871   if (access & ACC_FINAL || access & ACC_PRIVATE)
10872     return INVOKE_NONVIRTUAL;
10873
10874   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10875     return INVOKE_NONVIRTUAL;
10876
10877   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10878     return INVOKE_INTERFACE;
10879
10880   return INVOKE_VIRTUAL;
10881 }
10882
10883 /* Retrieve a refined list of matching methods. It covers the step
10884    15.11.2 (Compile-Time Step 2) */
10885
10886 static tree
10887 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
10888 {
10889   tree atl = end_params_node;           /* Arg Type List */
10890   tree method, signature, list, node;
10891   const char *candidates;               /* Used for error report */
10892   char *dup;
10893
10894   /* Fix the arguments */
10895   for (node = arg_list; node; node = TREE_CHAIN (node))
10896     {
10897       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10898       /* Non primitive type may have to be resolved */
10899       if (!JPRIMITIVE_TYPE_P (current_arg))
10900         resolve_and_layout (current_arg, NULL_TREE);
10901       /* And promoted */
10902       if (TREE_CODE (current_arg) == RECORD_TYPE)
10903         current_arg = promote_type (current_arg);
10904       atl = tree_cons (NULL_TREE, current_arg, atl);
10905     }
10906
10907   /* Presto. If we're dealing with an anonymous class and a
10908      constructor call, generate the right constructor now, since we
10909      know the arguments' types. */
10910
10911   if (lc && ANONYMOUS_CLASS_P (class))
10912     {
10913       tree saved_current_class;
10914       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10915       saved_current_class = current_class;
10916       current_class = class;
10917       fix_constructors (mdecl);
10918       current_class = saved_current_class;
10919     }
10920
10921   /* Find all candidates and then refine the list, searching for the
10922      most specific method. */
10923   list = find_applicable_accessible_methods_list (lc, class, name, atl);
10924   list = find_most_specific_methods_list (list);
10925   if (list && !TREE_CHAIN (list))
10926     return TREE_VALUE (list);
10927
10928   /* Issue an error. List candidates if any. Candidates are listed
10929      only if accessible (non accessible methods may end-up here for
10930      the sake of a better error report). */
10931   candidates = NULL;
10932   if (list)
10933     {
10934       tree current;
10935       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
10936       for (current = list; current; current = TREE_CHAIN (current))
10937         {
10938           tree cm = TREE_VALUE (current);
10939           char string [4096];
10940           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
10941             continue;
10942           sprintf
10943             (string, "  `%s' in `%s'%s",
10944              get_printable_method_name (cm),
10945              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
10946              (TREE_CHAIN (current) ? "\n" : ""));
10947           obstack_grow (&temporary_obstack, string, strlen (string));
10948         }
10949       obstack_1grow (&temporary_obstack, '\0');
10950       candidates = obstack_finish (&temporary_obstack);
10951     }
10952   /* Issue the error message */
10953   method = make_node (FUNCTION_TYPE);
10954   TYPE_ARG_TYPES (method) = atl;
10955   signature = build_java_argument_signature (method);
10956   dup = xstrdup (lang_printable_name (class, 0));
10957   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
10958                        (lc ? "constructor" : "method"),
10959                        (lc ? dup : IDENTIFIER_POINTER (name)),
10960                        IDENTIFIER_POINTER (signature), dup,
10961                        (candidates ? candidates : ""));
10962   free (dup);
10963   return NULL_TREE;
10964 }
10965
10966 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
10967    when we're looking for a constructor. */
10968
10969 static tree
10970 find_applicable_accessible_methods_list (int lc, tree class, tree name,
10971                                          tree arglist)
10972 {
10973   static htab_t searched_classes;
10974   static int search_not_done = 0;
10975   tree list = NULL_TREE, all_list = NULL_TREE;
10976   tree base_binfo;
10977   int i;
10978
10979   /* Check the hash table to determine if this class has been searched
10980      already. */
10981   if (searched_classes)
10982     {
10983       if (htab_find (searched_classes, class) != NULL)
10984         return NULL;
10985     }
10986   else
10987     {
10988       searched_classes = htab_create (10, htab_hash_pointer,
10989                                       htab_eq_pointer, NULL);
10990     }
10991
10992   search_not_done++;
10993   *htab_find_slot (searched_classes, class, INSERT) = class;
10994
10995   if (!CLASS_LOADED_P (class))
10996     {
10997       load_class (class, 1);
10998       safe_layout_class (class);
10999     }
11000
11001   /* Search interfaces */
11002   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11003       && CLASS_INTERFACE (TYPE_NAME (class)))
11004     {
11005       search_applicable_methods_list (lc, TYPE_METHODS (class),
11006                                       name, arglist, &list, &all_list);
11007       for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
11008         {
11009           tree t = BINFO_TYPE (base_binfo);
11010           tree rlist;
11011
11012           rlist = find_applicable_accessible_methods_list (lc,  t, name,
11013                                                            arglist);
11014           list = chainon (rlist, list);
11015         }
11016     }
11017   /* Search classes */
11018   else
11019     {
11020       search_applicable_methods_list (lc, TYPE_METHODS (class),
11021                                       name, arglist, &list, &all_list);
11022
11023       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11024          that we only search in class. Note that we should have found
11025          something at this point. */
11026       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11027         {
11028           lc = 1;
11029           if (!list)
11030             abort ();
11031         }
11032
11033       /* We must search all interfaces of this class */
11034       if (!lc)
11035         {
11036           for (i = 1;
11037                BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
11038             {
11039               tree t = BINFO_TYPE (base_binfo);
11040               if (t != object_type_node)
11041                 {
11042                   tree rlist
11043                     = find_applicable_accessible_methods_list (lc, t,
11044                                                                name, arglist);
11045                   list = chainon (rlist, list);
11046                 }
11047             }
11048         }
11049
11050       /* Search superclass */
11051       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11052         {
11053           tree rlist;
11054           class = CLASSTYPE_SUPER (class);
11055           rlist = find_applicable_accessible_methods_list (lc, class,
11056                                                            name, arglist);
11057           list = chainon (rlist, list);
11058         }
11059     }
11060
11061   search_not_done--;
11062
11063   /* We're done. Reset the searched classes list and finally search
11064      java.lang.Object if it wasn't searched already. */
11065   if (!search_not_done)
11066     {
11067       if (!lc
11068           && TYPE_METHODS (object_type_node)
11069           && htab_find (searched_classes, object_type_node) == NULL)
11070         {
11071           search_applicable_methods_list (lc,
11072                                           TYPE_METHODS (object_type_node),
11073                                           name, arglist, &list, &all_list);
11074         }
11075       htab_delete (searched_classes);
11076       searched_classes = NULL;
11077     }
11078
11079   /* Either return the list obtained or all selected (but
11080      inaccessible) methods for better error report. */
11081   return (!list ? all_list : list);
11082 }
11083
11084 /* Effectively search for the appropriate method in method */
11085
11086 static void
11087 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11088                                 tree *list, tree *all_list)
11089 {
11090   for (; method; method = TREE_CHAIN (method))
11091     {
11092       /* When dealing with constructor, stop here, otherwise search
11093          other classes */
11094       if (lc && !DECL_CONSTRUCTOR_P (method))
11095         continue;
11096       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11097                        || (DECL_NAME (method) != name)))
11098         continue;
11099
11100       if (argument_types_convertible (method, arglist))
11101         {
11102           /* Retain accessible methods only */
11103           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11104                                  method, NULL_TREE, 0))
11105             *list = tree_cons (NULL_TREE, method, *list);
11106           else
11107             /* Also retain all selected method here */
11108             *all_list = tree_cons (NULL_TREE, method, *list);
11109         }
11110     }
11111 }
11112
11113 /* 15.11.2.2 Choose the Most Specific Method */
11114
11115 static tree
11116 find_most_specific_methods_list (tree list)
11117 {
11118   int max = 0;
11119   int abstract, candidates;
11120   tree current, new_list = NULL_TREE;
11121   for (current = list; current; current = TREE_CHAIN (current))
11122     {
11123       tree method;
11124       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11125
11126       for (method = list; method; method = TREE_CHAIN (method))
11127         {
11128           tree method_v, current_v;
11129           /* Don't test a method against itself */
11130           if (method == current)
11131             continue;
11132
11133           method_v = TREE_VALUE (method);
11134           current_v = TREE_VALUE (current);
11135
11136           /* Compare arguments and location where methods where declared */
11137           if (argument_types_convertible (method_v, current_v))
11138             {
11139               if (valid_method_invocation_conversion_p
11140                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11141                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11142                       && enclosing_context_p (DECL_CONTEXT (method_v),
11143                                               DECL_CONTEXT (current_v))))
11144                 {
11145                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
11146                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11147                   max = (v > max ? v : max);
11148                 }
11149             }
11150         }
11151     }
11152
11153   /* Review the list and select the maximally specific methods */
11154   for (current = list, abstract = -1, candidates = -1;
11155        current; current = TREE_CHAIN (current))
11156     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11157       {
11158         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11159         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11160         candidates++;
11161       }
11162
11163   /* If we have several and they're all abstract, just pick the
11164      closest one. */
11165   if (candidates > 0 && candidates == abstract)
11166     {
11167       /* FIXME: merge the throws clauses.  There is no convenient way
11168          to do this in gcj right now, since ideally we'd like to
11169          introduce a new METHOD_DECL here, but that is really not
11170          possible.  */
11171       new_list = nreverse (new_list);
11172       TREE_CHAIN (new_list) = NULL_TREE;
11173       return new_list;
11174     }
11175
11176   /* We have several (we couldn't find a most specific), all but one
11177      are abstract, we pick the only non abstract one. */
11178   if (candidates > 0 && (candidates == abstract+1))
11179     {
11180       for (current = new_list; current; current = TREE_CHAIN (current))
11181         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11182           {
11183             TREE_CHAIN (current) = NULL_TREE;
11184             new_list = current;
11185           }
11186     }
11187
11188   /* If we can't find one, lower expectations and try to gather multiple
11189      maximally specific methods */
11190   while (!new_list && max)
11191     {
11192       while (--max > 0)
11193         {
11194           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11195             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11196         }
11197     }
11198
11199   return new_list;
11200 }
11201
11202 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11203    converted by method invocation conversion (5.3) to the type of the
11204    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11205    to change less often than M1. */
11206
11207 static GTY(()) tree m2_arg_value;
11208 static GTY(()) tree m2_arg_cache;
11209
11210 static int
11211 argument_types_convertible (tree m1, tree m2_or_arglist)
11212 {
11213   tree m1_arg, m2_arg;
11214
11215   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11216
11217   if (m2_arg_value == m2_or_arglist)
11218     m2_arg = m2_arg_cache;
11219   else
11220     {
11221       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11222          argument types */
11223       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11224         {
11225           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11226           if (!METHOD_STATIC (m2_or_arglist))
11227             m2_arg = TREE_CHAIN (m2_arg);
11228         }
11229       else
11230         m2_arg = m2_or_arglist;
11231
11232       m2_arg_value = m2_or_arglist;
11233       m2_arg_cache = m2_arg;
11234     }
11235
11236   while (m1_arg != end_params_node && m2_arg != end_params_node)
11237     {
11238       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11239       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11240                                                  TREE_VALUE (m2_arg)))
11241         break;
11242       m1_arg = TREE_CHAIN (m1_arg);
11243       m2_arg = TREE_CHAIN (m2_arg);
11244     }
11245   return m1_arg == end_params_node && m2_arg == end_params_node;
11246 }
11247
11248 /* Qualification routines */
11249
11250 /* Given a name x.y.z, look up x locally.  If it's found, save the
11251    decl.  If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11252    so that we later try and load the appropriate classes.  */
11253 static void
11254 qualify_ambiguous_name (tree id)
11255 {
11256   tree name, decl;
11257
11258   /* We inspect the first item of the qualification list.  As a sanity
11259      check, make sure that it is an identfier node.  */
11260   tree qual = EXPR_WFL_QUALIFICATION (id);
11261   tree qual_wfl = QUAL_WFL (qual);
11262
11263   if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11264     return;
11265
11266   name = EXPR_WFL_NODE (qual_wfl);
11267
11268   /* If we don't have an identifier, or we have a 'this' or 'super',
11269      then field access processing is all we need : there is nothing
11270      for us to do.  */
11271   if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11272       name == this_identifier_node ||
11273       name == super_identifier_node)
11274     return;
11275
11276   /* If name appears within the scope of a local variable declaration
11277      or parameter declaration, or is a field within an enclosing
11278      class, then it is an expression name.  Save the decl and let
11279      resolve_field_access do it's work.  */
11280   if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11281       (decl = lookup_field_wrapper (current_class, name)))
11282     {
11283       QUAL_RESOLUTION (qual) = decl;
11284       return;
11285     }
11286
11287   /* If name is a known class name (either declared or imported), mark
11288      us as a type name.  */
11289   if ((decl = resolve_and_layout (name, NULL_TREE)))
11290     {
11291       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11292       QUAL_RESOLUTION (qual) = decl;
11293     }
11294
11295   /* Check here that NAME isn't declared by more than one
11296      type-import-on-demand declaration of the compilation unit
11297      containing NAME. FIXME */
11298
11299   /* We couldn't find a declaration for the name.  Assume for now that
11300      we have a qualified class name that needs to be loaded from an
11301      external class file.  */
11302   else
11303     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11304
11305   /* Propagate the qualification across other components of the
11306      qualified name */
11307   for (qual = TREE_CHAIN (qual); qual;
11308        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11309     {
11310       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11311         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11312     }
11313
11314   /* Store the global qualification for the ambiguous part of ID back
11315      into ID fields */
11316   if (RESOLVE_TYPE_NAME_P (qual_wfl))
11317     RESOLVE_TYPE_NAME_P (id) = 1;
11318   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11319     RESOLVE_PACKAGE_NAME_P (id) = 1;
11320 }
11321
11322 /* Patch tree nodes in a function body. When a BLOCK is found, push
11323    local variable decls if present.
11324    Same as java_complete_lhs, but does resolve static finals to values. */
11325
11326 static tree
11327 java_complete_tree (tree node)
11328 {
11329   node = java_complete_lhs (node);
11330   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11331       && DECL_INITIAL (node) != NULL_TREE
11332       && !flag_emit_xref)
11333     {
11334       tree value = fold_constant_for_init (node, node);
11335       if (value != NULL_TREE)
11336         return value;
11337     }
11338   return node;
11339 }
11340
11341 static tree
11342 java_stabilize_reference (tree node)
11343 {
11344   if (TREE_CODE (node) == COMPOUND_EXPR)
11345     {
11346       tree op0 = TREE_OPERAND (node, 0);
11347       tree op1 = TREE_OPERAND (node, 1);
11348       TREE_OPERAND (node, 0) = save_expr (op0);
11349       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11350       return node;
11351     }
11352   return stabilize_reference (node);
11353 }
11354
11355 /* Patch tree nodes in a function body. When a BLOCK is found, push
11356    local variable decls if present.
11357    Same as java_complete_tree, but does not resolve static finals to values. */
11358
11359 static tree
11360 java_complete_lhs (tree node)
11361 {
11362   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11363   int flag;
11364
11365   /* CONVERT_EXPR always has its type set, even though it needs to be
11366      worked out. */
11367   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11368     return node;
11369
11370   /* The switch block implements cases processing container nodes
11371      first.  Contained nodes are always written back. Leaves come
11372      next and return a value. */
11373   switch (TREE_CODE (node))
11374     {
11375     case BLOCK:
11376
11377       /* 1- Block section.
11378          Set the local values on decl names so we can identify them
11379          faster when they're referenced. At that stage, identifiers
11380          are legal so we don't check for declaration errors. */
11381       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11382         {
11383           DECL_CONTEXT (cn) = current_function_decl;
11384           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11385         }
11386       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11387           CAN_COMPLETE_NORMALLY (node) = 1;
11388       else
11389         {
11390           tree stmt = BLOCK_EXPR_BODY (node);
11391           tree *ptr;
11392           int error_seen = 0;
11393           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11394             {
11395               /* Re-order from (((A; B); C); ...; Z) to
11396                  (A; (B; (C ; (...; Z)))).
11397                  This makes it easier to scan the statements left-to-right
11398                  without using recursion (which might overflow the stack
11399                  if the block has many statements. */
11400               for (;;)
11401                 {
11402                   tree left = TREE_OPERAND (stmt, 0);
11403                   if (TREE_CODE (left) != COMPOUND_EXPR)
11404                     break;
11405                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11406                   TREE_OPERAND (left, 1) = stmt;
11407                   stmt = left;
11408                 }
11409               BLOCK_EXPR_BODY (node) = stmt;
11410             }
11411
11412           /* Now do the actual complete, without deep recursion for
11413              long blocks. */
11414           ptr = &BLOCK_EXPR_BODY (node);
11415           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11416                  && !IS_EMPTY_STMT (TREE_OPERAND (*ptr, 1)))
11417             {
11418               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11419               tree *next = &TREE_OPERAND (*ptr, 1);
11420               TREE_OPERAND (*ptr, 0) = cur;
11421               if (IS_EMPTY_STMT (cur))
11422                 {
11423                   /* Optimization;  makes it easier to detect empty bodies.
11424                      Most useful for <clinit> with all-constant initializer. */
11425                   *ptr = *next;
11426                   continue;
11427                 }
11428               if (TREE_CODE (cur) == ERROR_MARK)
11429                 error_seen++;
11430               else if (! CAN_COMPLETE_NORMALLY (cur))
11431                 {
11432                   wfl_op2 = *next;
11433                   for (;;)
11434                     {
11435                       if (TREE_CODE (wfl_op2) == BLOCK)
11436                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11437                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11438                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11439                       else
11440                         break;
11441                     }
11442                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11443                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11444                     unreachable_stmt_error (*ptr);
11445                 }
11446               if (TREE_TYPE (*ptr) == NULL_TREE)
11447                 TREE_TYPE (*ptr) = void_type_node;
11448               ptr = next;
11449             }
11450           *ptr = java_complete_tree (*ptr);
11451
11452           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11453             return error_mark_node;
11454           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11455         }
11456       /* Turn local bindings to null */
11457       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11458         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11459
11460       TREE_TYPE (node) = void_type_node;
11461       break;
11462
11463       /* 2- They are expressions but ultimately deal with statements */
11464
11465     case THROW_EXPR:
11466       wfl_op1 = TREE_OPERAND (node, 0);
11467       COMPLETE_CHECK_OP_0 (node);
11468       /* 14.19 A throw statement cannot complete normally. */
11469       CAN_COMPLETE_NORMALLY (node) = 0;
11470       return patch_throw_statement (node, wfl_op1);
11471
11472     case SYNCHRONIZED_EXPR:
11473       wfl_op1 = TREE_OPERAND (node, 0);
11474       return patch_synchronized_statement (node, wfl_op1);
11475
11476     case TRY_EXPR:
11477       return patch_try_statement (node);
11478
11479     case TRY_FINALLY_EXPR:
11480       COMPLETE_CHECK_OP_0 (node);
11481       COMPLETE_CHECK_OP_1 (node);
11482       if (IS_EMPTY_STMT (TREE_OPERAND (node, 0)))
11483         /* Reduce try/finally nodes with an empty try block.  */
11484         return TREE_OPERAND (node, 1);
11485       if (IS_EMPTY_STMT (TREE_OPERAND (node, 1)))
11486         /* Likewise for an empty finally block.  */
11487         return TREE_OPERAND (node, 0);
11488       CAN_COMPLETE_NORMALLY (node)
11489         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11490            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11491       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11492       return node;
11493
11494     case LABELED_BLOCK_EXPR:
11495       PUSH_LABELED_BLOCK (node);
11496       if (LABELED_BLOCK_BODY (node))
11497         COMPLETE_CHECK_OP_1 (node);
11498       TREE_TYPE (node) = void_type_node;
11499       POP_LABELED_BLOCK ();
11500
11501       if (IS_EMPTY_STMT (LABELED_BLOCK_BODY (node)))
11502         {
11503           LABELED_BLOCK_BODY (node) = NULL_TREE;
11504           CAN_COMPLETE_NORMALLY (node) = 1;
11505         }
11506       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11507         CAN_COMPLETE_NORMALLY (node) = 1;
11508       return node;
11509
11510     case EXIT_BLOCK_EXPR:
11511       /* We don't complete operand 1, because it's the return value of
11512          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11513       return patch_bc_statement (node);
11514
11515     case CASE_EXPR:
11516       cn = java_complete_tree (TREE_OPERAND (node, 0));
11517       if (cn == error_mark_node)
11518         return cn;
11519
11520       /* First, the case expression must be constant. Values of final
11521          fields are accepted. */
11522       cn = fold (cn);
11523       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11524           && JDECL_P (TREE_OPERAND (cn, 1))
11525           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11526           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11527         {
11528           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11529                                        TREE_OPERAND (cn, 1));
11530         }
11531       /* Accept final locals too. */
11532       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn)
11533                && DECL_INITIAL (cn))
11534         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11535
11536       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11537         {
11538           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11539           parse_error_context (node, "Constant expression required");
11540           return error_mark_node;
11541         }
11542
11543       nn = ctxp->current_loop;
11544
11545       /* It must be assignable to the type of the switch expression. */
11546       if (!try_builtin_assignconv (NULL_TREE,
11547                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11548         {
11549           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11550           parse_error_context
11551             (wfl_operator,
11552              "Incompatible type for case. Can't convert `%s' to `int'",
11553              lang_printable_name (TREE_TYPE (cn), 0));
11554           return error_mark_node;
11555         }
11556
11557       cn = fold (convert (int_type_node, cn));
11558       TREE_CONSTANT_OVERFLOW (cn) = 0;
11559       CAN_COMPLETE_NORMALLY (cn) = 1;
11560
11561       /* Save the label on a list so that we can later check for
11562          duplicates.  */
11563       case_label_list = tree_cons (node, cn, case_label_list);
11564
11565       /* Multiple instance of a case label bearing the same value is
11566          checked later. The case expression is all right so far. */
11567       if (TREE_CODE (cn) == VAR_DECL)
11568         cn = DECL_INITIAL (cn);
11569       TREE_OPERAND (node, 0) = cn;
11570       TREE_TYPE (node) = void_type_node;
11571       CAN_COMPLETE_NORMALLY (node) = 1;
11572       TREE_SIDE_EFFECTS (node) = 1;
11573       break;
11574
11575     case DEFAULT_EXPR:
11576       nn = ctxp->current_loop;
11577       /* Only one default label is allowed per switch statement */
11578       if (SWITCH_HAS_DEFAULT (nn))
11579         {
11580           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11581           parse_error_context (wfl_operator,
11582                                "Duplicate case label: `default'");
11583           return error_mark_node;
11584         }
11585       else
11586         SWITCH_HAS_DEFAULT (nn) = 1;
11587       TREE_TYPE (node) = void_type_node;
11588       TREE_SIDE_EFFECTS (node) = 1;
11589       CAN_COMPLETE_NORMALLY (node) = 1;
11590       break;
11591
11592     case SWITCH_EXPR:
11593     case LOOP_EXPR:
11594       PUSH_LOOP (node);
11595       /* Check whether the loop was enclosed in a labeled
11596          statement. If not, create one, insert the loop in it and
11597          return the node */
11598       nn = patch_loop_statement (node);
11599
11600       /* Anyways, walk the body of the loop */
11601       if (TREE_CODE (node) == LOOP_EXPR)
11602         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11603       /* Switch statement: walk the switch expression and the cases */
11604       else
11605         node = patch_switch_statement (node);
11606
11607       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11608         nn = error_mark_node;
11609       else
11610         {
11611           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11612           /* If we returned something different, that's because we
11613              inserted a label. Pop the label too. */
11614           if (nn != node)
11615             {
11616               if (CAN_COMPLETE_NORMALLY (node))
11617                 CAN_COMPLETE_NORMALLY (nn) = 1;
11618               POP_LABELED_BLOCK ();
11619             }
11620         }
11621       POP_LOOP ();
11622       return nn;
11623
11624     case EXIT_EXPR:
11625       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11626       return patch_exit_expr (node);
11627
11628     case COND_EXPR:
11629       /* Condition */
11630       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11631       if (TREE_OPERAND (node, 0) == error_mark_node)
11632         return error_mark_node;
11633       /* then-else branches */
11634       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11635       if (TREE_OPERAND (node, 1) == error_mark_node)
11636         return error_mark_node;
11637       TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11638       if (TREE_OPERAND (node, 2) == error_mark_node)
11639         return error_mark_node;
11640       return patch_if_else_statement (node);
11641       break;
11642
11643     case CONDITIONAL_EXPR:
11644       /* Condition */
11645       wfl_op1 = TREE_OPERAND (node, 0);
11646       COMPLETE_CHECK_OP_0 (node);
11647       wfl_op2 = TREE_OPERAND (node, 1);
11648       COMPLETE_CHECK_OP_1 (node);
11649       wfl_op3 = TREE_OPERAND (node, 2);
11650       COMPLETE_CHECK_OP_2 (node);
11651       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11652
11653       /* 3- Expression section */
11654     case COMPOUND_EXPR:
11655       wfl_op2 = TREE_OPERAND (node, 1);
11656       TREE_OPERAND (node, 0) = nn =
11657         java_complete_tree (TREE_OPERAND (node, 0));
11658       if (IS_EMPTY_STMT (wfl_op2))
11659         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11660       else
11661         {
11662           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11663             {
11664               /* An unreachable condition in a do-while statement
11665                  is *not* (technically) an unreachable statement. */
11666               nn = wfl_op2;
11667               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11668                 nn = EXPR_WFL_NODE (nn);
11669               /* NN can be NULL_TREE exactly when UPDATE is, in
11670                  finish_for_loop.  */
11671               if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11672                 {
11673                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11674                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11675                     {
11676                       /* Perhaps this warning should have an
11677                          associated flag.  The code being compiled is
11678                          pedantically correct, but useless.  */
11679                       parse_warning_context (wfl_operator,
11680                                              "Unreachable statement");
11681                     }
11682                   else
11683                     parse_error_context (wfl_operator,
11684                                          "Unreachable statement");
11685                 }
11686             }
11687           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11688           if (TREE_OPERAND (node, 1) == error_mark_node)
11689             return error_mark_node;
11690           /* Even though we might allow the case where the first
11691              operand doesn't return normally, we still should compute
11692              CAN_COMPLETE_NORMALLY correctly.  */
11693           CAN_COMPLETE_NORMALLY (node)
11694             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11695                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11696         }
11697       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11698       break;
11699
11700     case RETURN_EXPR:
11701       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11702       return patch_return (node);
11703
11704     case EXPR_WITH_FILE_LOCATION:
11705       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11706           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11707         {
11708           tree wfl = node;
11709           node = resolve_expression_name (node, NULL);
11710           if (node == error_mark_node)
11711             return node;
11712           /* Keep line number information somewhere were it doesn't
11713              disrupt the completion process. */
11714           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11715             {
11716               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11717               TREE_OPERAND (node, 1) = wfl;
11718             }
11719           CAN_COMPLETE_NORMALLY (node) = 1;
11720         }
11721       else
11722         {
11723           tree body;
11724           int save_lineno = input_line;
11725           input_line = EXPR_WFL_LINENO (node);
11726           body = java_complete_tree (EXPR_WFL_NODE (node));
11727           input_line = save_lineno;
11728           EXPR_WFL_NODE (node) = body;
11729           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11730           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11731           if (IS_EMPTY_STMT (body) || TREE_CONSTANT (body))
11732             {
11733               /* Makes it easier to constant fold, detect empty bodies. */
11734               return body;
11735             }
11736           if (body == error_mark_node)
11737             {
11738               /* Its important for the evaluation of assignment that
11739                  this mark on the TREE_TYPE is propagated. */
11740               TREE_TYPE (node) = error_mark_node;
11741               return error_mark_node;
11742             }
11743           else
11744             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11745
11746         }
11747       break;
11748
11749     case NEW_ARRAY_EXPR:
11750       /* Patch all the dimensions */
11751       flag = 0;
11752       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11753         {
11754           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11755           tree dim = convert (int_type_node,
11756                               java_complete_tree (TREE_VALUE (cn)));
11757           if (dim == error_mark_node)
11758             {
11759               flag = 1;
11760               continue;
11761             }
11762           else
11763             {
11764               TREE_VALUE (cn) = dim;
11765               /* Setup the location of the current dimension, for
11766                  later error report. */
11767               TREE_PURPOSE (cn) =
11768                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11769               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11770             }
11771         }
11772       /* They complete the array creation expression, if no errors
11773          were found. */
11774       CAN_COMPLETE_NORMALLY (node) = 1;
11775       return (flag ? error_mark_node
11776               : force_evaluation_order (patch_newarray (node)));
11777
11778     case NEW_ANONYMOUS_ARRAY_EXPR:
11779       /* Create the array type if necessary. */
11780       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11781         {
11782           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11783           if (!(type = resolve_type_during_patch (type)))
11784             return error_mark_node;
11785           type = build_array_from_name (type, NULL_TREE,
11786                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11787           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11788         }
11789       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11790                                    ANONYMOUS_ARRAY_INITIALIZER (node));
11791       if (node == error_mark_node)
11792         return error_mark_node;
11793       CAN_COMPLETE_NORMALLY (node) = 1;
11794       return node;
11795
11796     case NEW_CLASS_EXPR:
11797     case CALL_EXPR:
11798       /* Complete function's argument(s) first */
11799       if (complete_function_arguments (node))
11800         return error_mark_node;
11801       else
11802         {
11803           tree decl, wfl = TREE_OPERAND (node, 0);
11804           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11805           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11806                            super_identifier_node);
11807           tree arguments;
11808           int location = EXPR_WFL_LINECOL (node);
11809
11810           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11811                                           from_super, 0, &decl);
11812           if (node == error_mark_node)
11813             return error_mark_node;
11814
11815           if (TREE_CODE (node) == CALL_EXPR
11816               && TREE_OPERAND (node, 1) != NULL_TREE)
11817             arguments = TREE_VALUE (TREE_OPERAND (node, 1));
11818           else
11819             arguments = NULL_TREE;
11820           check_thrown_exceptions (location, decl, arguments);
11821           /* If we call this(...), register signature and positions */
11822           if (in_this)
11823             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11824               tree_cons (wfl, decl,
11825                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
11826           CAN_COMPLETE_NORMALLY (node) = 1;
11827           return force_evaluation_order (node);
11828         }
11829
11830     case MODIFY_EXPR:
11831       /* Save potential wfls */
11832       wfl_op1 = TREE_OPERAND (node, 0);
11833       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11834
11835       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11836           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11837           && DECL_INITIAL (nn) != NULL_TREE)
11838         {
11839           tree value;
11840
11841           value = fold_constant_for_init (nn, nn);
11842
11843           /* When we have a primitype type, or a string and we're not
11844              emitting a class file, we actually don't want to generate
11845              anything for the assignment. */
11846           if (value != NULL_TREE &&
11847               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
11848                (TREE_TYPE (value) == string_ptr_type_node &&
11849                 ! flag_emit_class_files)))
11850             {
11851               /* Prepare node for patch_assignment */
11852               TREE_OPERAND (node, 1) = value;
11853               /* Call patch assignment to verify the assignment */
11854               if (patch_assignment (node, wfl_op1) == error_mark_node)
11855                 return error_mark_node;
11856               /* Set DECL_INITIAL properly (a conversion might have
11857                  been decided by patch_assignment) and return the
11858                  empty statement. */
11859               else
11860                 {
11861                   tree patched = patch_string (TREE_OPERAND (node, 1));
11862                   if (patched)
11863                     DECL_INITIAL (nn) = patched;
11864                   else
11865                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11866                   DECL_FIELD_FINAL_IUD (nn) = 1;
11867                   return build_java_empty_stmt ();
11868                 }
11869             }
11870           if (! flag_emit_class_files)
11871             DECL_INITIAL (nn) = NULL_TREE;
11872         }
11873       wfl_op2 = TREE_OPERAND (node, 1);
11874
11875       if (TREE_OPERAND (node, 0) == error_mark_node)
11876         return error_mark_node;
11877
11878       flag = COMPOUND_ASSIGN_P (wfl_op2);
11879       if (flag)
11880         {
11881           /* This might break when accessing outer field from inner
11882              class. TESTME, FIXME */
11883           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
11884
11885           /* Hand stabilize the lhs on both places */
11886           TREE_OPERAND (node, 0) = lvalue;
11887           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
11888             (flag_emit_class_files ? lvalue : save_expr (lvalue));
11889
11890           /* 15.25.2.a: Left hand is not an array access. FIXME */
11891           /* Now complete the RHS. We write it back later on. */
11892           nn = java_complete_tree (TREE_OPERAND (node, 1));
11893
11894           if ((cn = patch_string (nn)))
11895             nn = cn;
11896
11897           /* The last part of the rewrite for E1 op= E2 is to have
11898              E1 = (T)(E1 op E2), with T being the type of E1. */
11899           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
11900                                                TREE_TYPE (lvalue), nn));
11901
11902           /* If the assignment is compound and has reference type,
11903              then ensure the LHS has type String and nothing else.  */
11904           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
11905               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
11906             parse_error_context (wfl_op2,
11907                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
11908                                  lang_printable_name (TREE_TYPE (lvalue), 0));
11909
11910           /* 15.25.2.b: Left hand is an array access. FIXME */
11911         }
11912
11913       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
11914          function to complete this RHS. Note that a NEW_ARRAY_INIT
11915          might have been already fully expanded if created as a result
11916          of processing an anonymous array initializer. We avoid doing
11917          the operation twice by testing whether the node already bears
11918          a type. */
11919       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
11920         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
11921                                    TREE_OPERAND (node, 1));
11922       /* Otherwise we simply complete the RHS */
11923       else
11924         nn = java_complete_tree (TREE_OPERAND (node, 1));
11925
11926       if (nn == error_mark_node)
11927         return error_mark_node;
11928
11929       /* Write back the RHS as we evaluated it. */
11930       TREE_OPERAND (node, 1) = nn;
11931
11932       /* In case we're handling = with a String as a RHS, we need to
11933          produce a String out of the RHS (it might still be a
11934          STRING_CST or a StringBuffer at this stage */
11935       if ((nn = patch_string (TREE_OPERAND (node, 1))))
11936         TREE_OPERAND (node, 1) = nn;
11937
11938       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
11939                                         TREE_OPERAND (node, 1))))
11940         {
11941           /* We return error_mark_node if outer_field_access_fix
11942              detects we write into a final. */
11943           if (nn == error_mark_node)
11944             return error_mark_node;
11945           node = nn;
11946         }
11947       else
11948         {
11949           node = patch_assignment (node, wfl_op1);
11950           if (node == error_mark_node)
11951             return error_mark_node;
11952           /* Reorganize the tree if necessary. */
11953           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
11954                        || JSTRING_P (TREE_TYPE (node))))
11955             node = java_refold (node);
11956         }
11957
11958       /* Seek to set DECL_INITIAL to a proper value, since it might have
11959          undergone a conversion in patch_assignment. We do that only when
11960          it's necessary to have DECL_INITIAL properly set. */
11961       nn = TREE_OPERAND (node, 0);
11962       if (TREE_CODE (nn) == VAR_DECL
11963           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
11964           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
11965           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
11966               || TREE_TYPE (nn) == string_ptr_type_node))
11967         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11968
11969       CAN_COMPLETE_NORMALLY (node) = 1;
11970       return node;
11971
11972     case MULT_EXPR:
11973     case PLUS_EXPR:
11974     case MINUS_EXPR:
11975     case LSHIFT_EXPR:
11976     case RSHIFT_EXPR:
11977     case URSHIFT_EXPR:
11978     case BIT_AND_EXPR:
11979     case BIT_XOR_EXPR:
11980     case BIT_IOR_EXPR:
11981     case TRUNC_MOD_EXPR:
11982     case TRUNC_DIV_EXPR:
11983     case RDIV_EXPR:
11984     case TRUTH_ANDIF_EXPR:
11985     case TRUTH_ORIF_EXPR:
11986     case EQ_EXPR:
11987     case NE_EXPR:
11988     case GT_EXPR:
11989     case GE_EXPR:
11990     case LT_EXPR:
11991     case LE_EXPR:
11992       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
11993          knows how to handle those cases. */
11994       wfl_op1 = TREE_OPERAND (node, 0);
11995       wfl_op2 = TREE_OPERAND (node, 1);
11996
11997       CAN_COMPLETE_NORMALLY (node) = 1;
11998       /* Don't complete string nodes if dealing with the PLUS operand. */
11999       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12000         {
12001           nn = java_complete_tree (wfl_op1);
12002           if (nn == error_mark_node)
12003             return error_mark_node;
12004
12005           TREE_OPERAND (node, 0) = nn;
12006         }
12007       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12008         {
12009           nn = java_complete_tree (wfl_op2);
12010           if (nn == error_mark_node)
12011             return error_mark_node;
12012
12013           TREE_OPERAND (node, 1) = nn;
12014         }
12015       return patch_binop (node, wfl_op1, wfl_op2);
12016
12017     case INSTANCEOF_EXPR:
12018       wfl_op1 = TREE_OPERAND (node, 0);
12019       COMPLETE_CHECK_OP_0 (node);
12020       if (flag_emit_xref)
12021         {
12022           TREE_TYPE (node) = boolean_type_node;
12023           return node;
12024         }
12025       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12026
12027     case UNARY_PLUS_EXPR:
12028     case NEGATE_EXPR:
12029     case TRUTH_NOT_EXPR:
12030     case BIT_NOT_EXPR:
12031     case PREDECREMENT_EXPR:
12032     case PREINCREMENT_EXPR:
12033     case POSTDECREMENT_EXPR:
12034     case POSTINCREMENT_EXPR:
12035     case CONVERT_EXPR:
12036       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12037          how to handle those cases. */
12038       wfl_op1 = TREE_OPERAND (node, 0);
12039       CAN_COMPLETE_NORMALLY (node) = 1;
12040       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12041       if (TREE_OPERAND (node, 0) == error_mark_node)
12042         return error_mark_node;
12043       node = patch_unaryop (node, wfl_op1);
12044       CAN_COMPLETE_NORMALLY (node) = 1;
12045       break;
12046
12047     case ARRAY_REF:
12048       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12049          how to handle those cases. */
12050       wfl_op1 = TREE_OPERAND (node, 0);
12051       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12052       if (TREE_OPERAND (node, 0) == error_mark_node)
12053         return error_mark_node;
12054       if (!flag_emit_class_files && !flag_emit_xref)
12055         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12056       /* The same applies to wfl_op2 */
12057       wfl_op2 = TREE_OPERAND (node, 1);
12058       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12059       if (TREE_OPERAND (node, 1) == error_mark_node)
12060         return error_mark_node;
12061       if (!flag_emit_class_files && !flag_emit_xref)
12062         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12063       return patch_array_ref (node);
12064
12065     case RECORD_TYPE:
12066       return node;;
12067
12068     case COMPONENT_REF:
12069       /* The first step in the re-write of qualified name handling.  FIXME.
12070          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12071       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12072       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12073         {
12074           tree name = TREE_OPERAND (node, 1);
12075           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12076           if (field == NULL_TREE)
12077             {
12078               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12079               return error_mark_node;
12080             }
12081           if (! FIELD_STATIC (field))
12082             {
12083               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12084               return error_mark_node;
12085             }
12086           return field;
12087         }
12088       else
12089         abort ();
12090       break;
12091
12092     case THIS_EXPR:
12093       /* Can't use THIS in a static environment */
12094       if (!current_this)
12095         {
12096           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12097           parse_error_context (wfl_operator,
12098                                "Keyword `this' used outside allowed context");
12099           TREE_TYPE (node) = error_mark_node;
12100           return error_mark_node;
12101         }
12102       if (ctxp->explicit_constructor_p)
12103         {
12104           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12105           parse_error_context
12106             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12107           TREE_TYPE (node) = error_mark_node;
12108           return error_mark_node;
12109         }
12110       return current_this;
12111
12112     case CLASS_LITERAL:
12113       CAN_COMPLETE_NORMALLY (node) = 1;
12114       node = patch_incomplete_class_ref (node);
12115       if (node == error_mark_node)
12116         return error_mark_node;
12117       break;
12118
12119     default:
12120       CAN_COMPLETE_NORMALLY (node) = 1;
12121       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12122          and it's time to turn it into the appropriate String object */
12123       if ((nn = patch_string (node)))
12124         node = nn;
12125       else
12126         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12127     }
12128   return node;
12129 }
12130
12131 /* Complete function call's argument. Return a nonzero value is an
12132    error was found.  */
12133
12134 static int
12135 complete_function_arguments (tree node)
12136 {
12137   int flag = 0;
12138   tree cn;
12139
12140   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12141   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12142     {
12143       tree wfl = TREE_VALUE (cn), parm, temp;
12144       parm = java_complete_tree (wfl);
12145
12146       if (parm == error_mark_node)
12147         {
12148           flag = 1;
12149           continue;
12150         }
12151       /* If we have a string literal that we haven't transformed yet or a
12152          crafted string buffer, as a result of the use of the String
12153          `+' operator. Build `parm.toString()' and expand it. */
12154       if ((temp = patch_string (parm)))
12155         parm = temp;
12156
12157       TREE_VALUE (cn) = parm;
12158     }
12159   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12160   return flag;
12161 }
12162
12163 /* Sometimes (for loops and variable initialized during their
12164    declaration), we want to wrap a statement around a WFL and turn it
12165    debugable.  */
12166
12167 static tree
12168 build_debugable_stmt (int location, tree stmt)
12169 {
12170   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12171     {
12172       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12173       EXPR_WFL_LINECOL (stmt) = location;
12174     }
12175   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12176   return stmt;
12177 }
12178
12179 static tree
12180 build_expr_block (tree body, tree decls)
12181 {
12182   tree node = make_node (BLOCK);
12183   BLOCK_EXPR_DECLS (node) = decls;
12184   BLOCK_EXPR_BODY (node) = body;
12185   if (body)
12186     TREE_TYPE (node) = TREE_TYPE (body);
12187   TREE_SIDE_EFFECTS (node) = 1;
12188   return node;
12189 }
12190
12191 /* Create a new function block and link it appropriately to current
12192    function block chain */
12193
12194 static tree
12195 enter_block (void)
12196 {
12197   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12198
12199   /* Link block B supercontext to the previous block. The current
12200      function DECL is used as supercontext when enter_a_block is called
12201      for the first time for a given function. The current function body
12202      (DECL_FUNCTION_BODY) is set to be block B.  */
12203
12204   tree fndecl = current_function_decl;
12205
12206   if (!fndecl) {
12207     BLOCK_SUPERCONTEXT (b) = current_static_block;
12208     current_static_block = b;
12209   }
12210
12211   else if (!DECL_FUNCTION_BODY (fndecl))
12212     {
12213       BLOCK_SUPERCONTEXT (b) = fndecl;
12214       DECL_FUNCTION_BODY (fndecl) = b;
12215     }
12216   else
12217     {
12218       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12219       DECL_FUNCTION_BODY (fndecl) = b;
12220     }
12221   return b;
12222 }
12223
12224 /* Exit a block by changing the current function body
12225    (DECL_FUNCTION_BODY) to the current block super context, only if
12226    the block being exited isn't the method's top level one.  */
12227
12228 static tree
12229 exit_block (void)
12230 {
12231   tree b;
12232   if (current_function_decl)
12233     {
12234       b = DECL_FUNCTION_BODY (current_function_decl);
12235       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12236         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12237     }
12238   else
12239     {
12240       b = current_static_block;
12241
12242       if (BLOCK_SUPERCONTEXT (b))
12243         current_static_block = BLOCK_SUPERCONTEXT (b);
12244     }
12245   return b;
12246 }
12247
12248 /* Lookup for NAME in the nested function's blocks, all the way up to
12249    the current toplevel one. It complies with Java's local variable
12250    scoping rules.  */
12251
12252 static tree
12253 lookup_name_in_blocks (tree name)
12254 {
12255   tree b = GET_CURRENT_BLOCK (current_function_decl);
12256
12257   while (b != current_function_decl)
12258     {
12259       tree current;
12260
12261       /* Paranoid sanity check. To be removed */
12262       if (TREE_CODE (b) != BLOCK)
12263         abort ();
12264
12265       for (current = BLOCK_EXPR_DECLS (b); current;
12266            current = TREE_CHAIN (current))
12267         if (DECL_NAME (current) == name)
12268           return current;
12269       b = BLOCK_SUPERCONTEXT (b);
12270     }
12271   return NULL_TREE;
12272 }
12273
12274 static void
12275 maybe_absorb_scoping_blocks (void)
12276 {
12277   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12278     {
12279       tree b = exit_block ();
12280       java_method_add_stmt (current_function_decl, b);
12281       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12282     }
12283 }
12284
12285 \f
12286 /* This section of the source is reserved to build_* functions that
12287    are building incomplete tree nodes and the patch_* functions that
12288    are completing them.  */
12289
12290 /* Wrap a non WFL node around a WFL.  */
12291
12292 static tree
12293 build_wfl_wrap (tree node, int location)
12294 {
12295   tree wfl, node_to_insert = node;
12296
12297   /* We want to process THIS . xxx symbolically, to keep it consistent
12298      with the way we're processing SUPER. A THIS from a primary as a
12299      different form than a SUPER. Turn THIS into something symbolic */
12300   if (TREE_CODE (node) == THIS_EXPR)
12301     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12302   else
12303     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12304
12305   EXPR_WFL_LINECOL (wfl) = location;
12306   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12307   return wfl;
12308 }
12309
12310 /* Build a super() constructor invocation. Returns an empty statement if
12311    we're currently dealing with the class java.lang.Object. */
12312
12313 static tree
12314 build_super_invocation (tree mdecl)
12315 {
12316   if (DECL_CONTEXT (mdecl) == object_type_node)
12317     return build_java_empty_stmt ();
12318   else
12319     {
12320       tree super_wfl = build_wfl_node (super_identifier_node);
12321       tree a = NULL_TREE, t;
12322
12323       /* This is called after parsing is done, so the parser context
12324          won't be accurate. Set location info from current_class decl. */
12325       tree class_wfl = lookup_cl (TYPE_NAME (current_class));
12326       EXPR_WFL_LINECOL (super_wfl) = EXPR_WFL_LINECOL (class_wfl);
12327
12328       /* If we're dealing with an anonymous class, pass the arguments
12329          of the crafted constructor along. */
12330       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12331         {
12332           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12333           for (; t != end_params_node; t = TREE_CHAIN (t))
12334             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12335         }
12336       return build_method_invocation (super_wfl, a);
12337     }
12338 }
12339
12340 /* Build a SUPER/THIS qualified method invocation.  */
12341
12342 static tree
12343 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12344                                        int lloc, int rloc)
12345 {
12346   tree invok;
12347   tree wfl =
12348     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12349   EXPR_WFL_LINECOL (wfl) = lloc;
12350   invok = build_method_invocation (name, args);
12351   return make_qualified_primary (wfl, invok, rloc);
12352 }
12353
12354 /* Build an incomplete CALL_EXPR node. */
12355
12356 static tree
12357 build_method_invocation (tree name, tree args)
12358 {
12359   tree call = build3 (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12360   TREE_SIDE_EFFECTS (call) = 1;
12361   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12362   return call;
12363 }
12364
12365 /* Build an incomplete new xxx(...) node. */
12366
12367 static tree
12368 build_new_invocation (tree name, tree args)
12369 {
12370   tree call = build3 (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12371   TREE_SIDE_EFFECTS (call) = 1;
12372   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12373   return call;
12374 }
12375
12376 /* Build an incomplete assignment expression. */
12377
12378 static tree
12379 build_assignment (int op, int op_location, tree lhs, tree rhs)
12380 {
12381   tree assignment;
12382   /* Build the corresponding binop if we deal with a Compound
12383      Assignment operator. Mark the binop sub-tree as part of a
12384      Compound Assignment expression */
12385   if (op != ASSIGN_TK)
12386     {
12387       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12388       COMPOUND_ASSIGN_P (rhs) = 1;
12389     }
12390   assignment = build2 (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12391   TREE_SIDE_EFFECTS (assignment) = 1;
12392   EXPR_WFL_LINECOL (assignment) = op_location;
12393   return assignment;
12394 }
12395
12396 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12397    the buffer.  This is used only for string conversion.  */
12398 static char *
12399 string_convert_int_cst (tree node)
12400 {
12401   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12402   static char buffer[21];
12403
12404   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12405   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12406   char *p = buffer + sizeof (buffer);
12407   int neg = 0;
12408
12409   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12410                                   << (HOST_BITS_PER_WIDE_INT - 1));
12411
12412   *--p = '\0';
12413
12414   /* If negative, note the fact and negate the value.  */
12415   if ((hi & hibit))
12416     {
12417       lo = ~lo;
12418       hi = ~hi;
12419       if (++lo == 0)
12420         ++hi;
12421       neg = 1;
12422     }
12423
12424   /* Divide by 10 until there are no bits left.  */
12425   do
12426     {
12427       unsigned HOST_WIDE_INT acc = 0;
12428       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12429       unsigned int i;
12430
12431       /* Use long division to compute the result and the remainder.  */
12432       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12433         {
12434           /* Shift a bit into accumulator.  */
12435           acc <<= 1;
12436           if ((hi & hibit))
12437             acc |= 1;
12438
12439           /* Shift the value.  */
12440           hi <<= 1;
12441           if ((lo & hibit))
12442             hi |= 1;
12443           lo <<= 1;
12444
12445           /* Shift the correct bit into the result.  */
12446           outhi <<= 1;
12447           if ((outlo & hibit))
12448             outhi |= 1;
12449           outlo <<= 1;
12450           if (acc >= 10)
12451             {
12452               acc -= 10;
12453               outlo |= 1;
12454             }
12455         }
12456
12457       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12458       *--p = '\060' + acc;
12459
12460       hi = outhi;
12461       lo = outlo;
12462     }
12463   while (hi || lo);
12464
12465   if (neg)
12466     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12467
12468   return p;
12469 }
12470
12471 /* Print an INTEGER_CST node in a static buffer, and return the
12472    buffer.  This is used only for error handling.  */
12473 char *
12474 print_int_node (tree node)
12475 {
12476   static char buffer [80];
12477   if (TREE_CONSTANT_OVERFLOW (node))
12478     sprintf (buffer, "<overflow>");
12479
12480   if (TREE_INT_CST_HIGH (node) == 0)
12481     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12482              TREE_INT_CST_LOW (node));
12483   else if (TREE_INT_CST_HIGH (node) == -1
12484            && TREE_INT_CST_LOW (node) != 0)
12485     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12486              -TREE_INT_CST_LOW (node));
12487   else
12488     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12489              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12490
12491   return buffer;
12492 }
12493
12494 \f
12495 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12496    context.  */
12497
12498 /* 15.25 Assignment operators. */
12499
12500 static tree
12501 patch_assignment (tree node, tree wfl_op1)
12502 {
12503   tree rhs = TREE_OPERAND (node, 1);
12504   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12505   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12506   int error_found = 0;
12507   int lvalue_from_array = 0;
12508   int is_return = 0;
12509
12510   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12511
12512   /* Lhs can be a named variable */
12513   if (JDECL_P (lvalue))
12514     {
12515       lhs_type = TREE_TYPE (lvalue);
12516     }
12517   /* Or Lhs can be an array access. */
12518   else if (TREE_CODE (lvalue) == ARRAY_REF)
12519     {
12520       lhs_type = TREE_TYPE (lvalue);
12521       lvalue_from_array = 1;
12522     }
12523   /* Or a field access */
12524   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12525     lhs_type = TREE_TYPE (lvalue);
12526   /* Or a function return slot */
12527   else if (TREE_CODE (lvalue) == RESULT_DECL)
12528     {
12529       /* If the return type is an integral type, then we create the
12530          RESULT_DECL with a promoted type, but we need to do these
12531          checks against the unpromoted type to ensure type safety.  So
12532          here we look at the real type, not the type of the decl we
12533          are modifying.  */
12534       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12535       is_return = 1;
12536     }
12537   /* Otherwise, we might want to try to write into an optimized static
12538      final, this is an of a different nature, reported further on. */
12539   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12540            && resolve_expression_name (wfl_op1, &llvalue))
12541     {
12542       lhs_type = TREE_TYPE (lvalue);
12543     }
12544   else
12545     {
12546       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12547       error_found = 1;
12548     }
12549
12550   rhs_type = TREE_TYPE (rhs);
12551
12552   /* 5.1 Try the assignment conversion for builtin type. */
12553   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12554
12555   /* 5.2 If it failed, try a reference conversion */
12556   if (!new_rhs)
12557     new_rhs = try_reference_assignconv (lhs_type, rhs);
12558
12559   /* 15.25.2 If we have a compound assignment, convert RHS into the
12560      type of the LHS */
12561   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12562     new_rhs = convert (lhs_type, rhs);
12563
12564   /* Explicit cast required. This is an error */
12565   if (!new_rhs)
12566     {
12567       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12568       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12569       tree wfl;
12570       char operation [32];      /* Max size known */
12571
12572       /* If the assignment is part of a declaration, we use the WFL of
12573          the declared variable to point out the error and call it a
12574          declaration problem. If the assignment is a genuine =
12575          operator, we call is a operator `=' problem, otherwise we
12576          call it an assignment problem. In both of these last cases,
12577          we use the WFL of the operator to indicate the error. */
12578
12579       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12580         {
12581           wfl = wfl_op1;
12582           strcpy (operation, "declaration");
12583         }
12584       else
12585         {
12586           wfl = wfl_operator;
12587           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12588             strcpy (operation, "assignment");
12589           else if (is_return)
12590             strcpy (operation, "`return'");
12591           else
12592             strcpy (operation, "`='");
12593         }
12594
12595       if (!valid_cast_to_p (rhs_type, lhs_type))
12596         parse_error_context
12597           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12598            operation, t1, t2);
12599       else
12600         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12601                              operation, t1, t2);
12602       free (t1); free (t2);
12603       error_found = 1;
12604     }
12605
12606   if (error_found)
12607     return error_mark_node;
12608
12609   /* If we're processing a `return' statement, promote the actual type
12610      to the promoted type.  */
12611   if (is_return)
12612     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12613
12614   /* 10.10: Array Store Exception runtime check */
12615   if (!flag_emit_class_files
12616       && !flag_emit_xref
12617       && lvalue_from_array
12618       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12619     {
12620       tree array, store_check, base, index_expr;
12621
12622       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12623       new_rhs = save_expr (new_rhs);
12624
12625       /* Get the INDIRECT_REF. */
12626       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12627       /* Get the array pointer expr. */
12628       array = TREE_OPERAND (array, 0);
12629       store_check = build_java_arraystore_check (array, new_rhs);
12630
12631       index_expr = TREE_OPERAND (lvalue, 1);
12632
12633       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12634         {
12635           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12636              happen before the store check, so prepare to insert the store
12637              check within the second operand of the existing COMPOUND_EXPR. */
12638           base = index_expr;
12639         }
12640       else
12641         base = lvalue;
12642
12643       index_expr = TREE_OPERAND (base, 1);
12644       TREE_OPERAND (base, 1) = build2 (COMPOUND_EXPR, TREE_TYPE (index_expr),
12645                                        store_check, index_expr);
12646     }
12647
12648   /* Final locals can be used as case values in switch
12649      statement. Prepare them for this eventuality. */
12650   if (TREE_CODE (lvalue) == VAR_DECL
12651       && DECL_FINAL (lvalue)
12652       && TREE_CONSTANT (new_rhs)
12653       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12654       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12655       )
12656     {
12657       TREE_CONSTANT (lvalue) = 1;
12658       TREE_INVARIANT (lvalue) = 1;
12659       DECL_INITIAL (lvalue) = new_rhs;
12660     }
12661
12662   /* Copy the rhs if it's a reference.  */
12663   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12664     {
12665       switch (TREE_CODE (new_rhs))
12666         {
12667         case ARRAY_REF:
12668         case INDIRECT_REF:
12669         case COMPONENT_REF:
12670           /* Transform a = foo.bar
12671              into a = ({int tmp; tmp = foo.bar;}).
12672              We need to ensure that if a read from memory fails
12673              because of a NullPointerException, a destination variable
12674              will remain unchanged.  An explicit temporary does what
12675              we need.
12676
12677              If flag_check_references is set, this is unnecessary
12678              because we'll check each reference before doing any
12679              reads.  If optimize is not set the result will never be
12680              written to a stack slot that contains the LHS.  */
12681           {
12682             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12683                                    TREE_TYPE (new_rhs));
12684             tree block = make_node (BLOCK);
12685             tree assignment
12686               = build2 (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12687             DECL_CONTEXT (tmp) = current_function_decl;
12688             TREE_TYPE (block) = TREE_TYPE (new_rhs);
12689             BLOCK_VARS (block) = tmp;
12690             BLOCK_EXPR_BODY (block) = assignment;
12691             TREE_SIDE_EFFECTS (block) = 1;
12692             new_rhs = block;
12693           }
12694           break;
12695         default:
12696           break;
12697         }
12698     }
12699
12700   TREE_OPERAND (node, 0) = lvalue;
12701   TREE_OPERAND (node, 1) = new_rhs;
12702   TREE_TYPE (node) = lhs_type;
12703   return node;
12704 }
12705
12706 /* Check that type SOURCE can be cast into type DEST. If the cast
12707    can't occur at all, return NULL; otherwise, return a possibly
12708    modified rhs.  */
12709
12710 static tree
12711 try_reference_assignconv (tree lhs_type, tree rhs)
12712 {
12713   tree new_rhs = NULL_TREE;
12714   tree rhs_type = TREE_TYPE (rhs);
12715
12716   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12717     {
12718       /* `null' may be assigned to any reference type */
12719       if (rhs == null_pointer_node)
12720         new_rhs = null_pointer_node;
12721       /* Try the reference assignment conversion */
12722       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12723         new_rhs = rhs;
12724       /* This is a magic assignment that we process differently */
12725       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12726         new_rhs = rhs;
12727     }
12728   return new_rhs;
12729 }
12730
12731 /* Check that RHS can be converted into LHS_TYPE by the assignment
12732    conversion (5.2), for the cases of RHS being a builtin type. Return
12733    NULL_TREE if the conversion fails or if because RHS isn't of a
12734    builtin type. Return a converted RHS if the conversion is possible.  */
12735
12736 static tree
12737 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12738 {
12739   tree new_rhs = NULL_TREE;
12740   tree rhs_type = TREE_TYPE (rhs);
12741
12742   /* Handle boolean specially.  */
12743   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12744       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12745     {
12746       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12747           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12748         new_rhs = rhs;
12749     }
12750
12751   /* 5.1.1 Try Identity Conversion,
12752      5.1.2 Try Widening Primitive Conversion */
12753   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12754     new_rhs = convert (lhs_type, rhs);
12755
12756   /* Try a narrowing primitive conversion (5.1.3):
12757        - expression is a constant expression of type byte, short, char,
12758          or int, AND
12759        - variable is byte, short or char AND
12760        - The value of the expression is representable in the type of the
12761          variable */
12762   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12763             || rhs_type == char_type_node || rhs_type == int_type_node)
12764             && TREE_CONSTANT (rhs)
12765            && (lhs_type == byte_type_node || lhs_type == char_type_node
12766                || lhs_type == short_type_node))
12767     {
12768       if (int_fits_type_p (rhs, lhs_type))
12769         new_rhs = convert (lhs_type, rhs);
12770       else if (wfl_op1)         /* Might be called with a NULL */
12771         parse_warning_context
12772           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12773            print_int_node (rhs), lang_printable_name (lhs_type, 0));
12774       /* Reported a warning that will turn into an error further
12775          down, so we don't return */
12776     }
12777
12778   return new_rhs;
12779 }
12780
12781 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12782    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12783    0 is the conversion test fails.  This implements parts the method
12784    invocation conversion (5.3).  */
12785
12786 static int
12787 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
12788 {
12789   /* 5.1.1: This is the identity conversion part. */
12790   if (lhs_type == rhs_type)
12791     return 1;
12792
12793   /* Reject non primitive types and boolean conversions.  */
12794   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12795     return 0;
12796
12797   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12798      than a char can't be converted into a char. Short can't too, but
12799      the < test below takes care of that */
12800   if (lhs_type == char_type_node && rhs_type == byte_type_node)
12801     return 0;
12802
12803   /* Accept all promoted type here. Note, we can't use <= in the test
12804      below, because we still need to bounce out assignments of short
12805      to char and the likes */
12806   if (lhs_type == int_type_node
12807       && (rhs_type == promoted_byte_type_node
12808           || rhs_type == promoted_short_type_node
12809           || rhs_type == promoted_char_type_node
12810           || rhs_type == promoted_boolean_type_node))
12811     return 1;
12812
12813   /* From here, an integral is widened if its precision is smaller
12814      than the precision of the LHS or if the LHS is a floating point
12815      type, or the RHS is a float and the RHS a double. */
12816   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12817        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12818       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12819       || (rhs_type == float_type_node && lhs_type == double_type_node))
12820     return 1;
12821
12822   return 0;
12823 }
12824
12825 /* Check that something of SOURCE type can be assigned or cast to
12826    something of DEST type at runtime. Return 1 if the operation is
12827    valid, 0 otherwise. If CAST is set to 1, we're treating the case
12828    were SOURCE is cast into DEST, which borrows a lot of the
12829    assignment check. */
12830
12831 static int
12832 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
12833 {
12834   /* SOURCE or DEST might be null if not from a declared entity. */
12835   if (!source || !dest)
12836     return 0;
12837   if (JNULLP_TYPE_P (source))
12838     return 1;
12839   if (TREE_CODE (source) == POINTER_TYPE)
12840     source = TREE_TYPE (source);
12841   if (TREE_CODE (dest) == POINTER_TYPE)
12842     dest = TREE_TYPE (dest);
12843
12844   /* If source and dest are being compiled from bytecode, they may need to
12845      be loaded. */
12846   if (CLASS_P (source) && !CLASS_LOADED_P (source))
12847     {
12848       load_class (source, 1);
12849       safe_layout_class (source);
12850     }
12851   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
12852     {
12853       load_class (dest, 1);
12854       safe_layout_class (dest);
12855     }
12856
12857   /* Case where SOURCE is a class type */
12858   if (TYPE_CLASS_P (source))
12859     {
12860       if (TYPE_CLASS_P (dest))
12861         return  (source == dest
12862                  || inherits_from_p (source, dest)
12863                  || (cast && inherits_from_p (dest, source)));
12864       if (TYPE_INTERFACE_P (dest))
12865         {
12866           /* If doing a cast and SOURCE is final, the operation is
12867              always correct a compile time (because even if SOURCE
12868              does not implement DEST, a subclass of SOURCE might). */
12869           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12870             return 1;
12871           /* Otherwise, SOURCE must implement DEST */
12872           return interface_of_p (dest, source);
12873         }
12874       /* DEST is an array, cast permitted if SOURCE is of Object type */
12875       return (cast && source == object_type_node ? 1 : 0);
12876     }
12877   if (TYPE_INTERFACE_P (source))
12878     {
12879       if (TYPE_CLASS_P (dest))
12880         {
12881           /* If not casting, DEST must be the Object type */
12882           if (!cast)
12883             return dest == object_type_node;
12884           /* We're doing a cast. The cast is always valid is class
12885              DEST is not final, otherwise, DEST must implement SOURCE */
12886           else if (!CLASS_FINAL (TYPE_NAME (dest)))
12887             return 1;
12888           else
12889             return interface_of_p (source, dest);
12890         }
12891       if (TYPE_INTERFACE_P (dest))
12892         {
12893           /* If doing a cast, then if SOURCE and DEST contain method
12894              with the same signature but different return type, then
12895              this is a (compile time) error */
12896           if (cast)
12897             {
12898               tree method_source, method_dest;
12899               tree source_type;
12900               tree source_sig;
12901               tree source_name;
12902               for (method_source = TYPE_METHODS (source); method_source;
12903                    method_source = TREE_CHAIN (method_source))
12904                 {
12905                   source_sig =
12906                     build_java_argument_signature (TREE_TYPE (method_source));
12907                   source_type = TREE_TYPE (TREE_TYPE (method_source));
12908                   source_name = DECL_NAME (method_source);
12909                   for (method_dest = TYPE_METHODS (dest);
12910                        method_dest; method_dest = TREE_CHAIN (method_dest))
12911                     if (source_sig ==
12912                         build_java_argument_signature (TREE_TYPE (method_dest))
12913                         && source_name == DECL_NAME (method_dest)
12914                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
12915                       return 0;
12916                 }
12917               return 1;
12918             }
12919           else
12920             return source == dest || interface_of_p (dest, source);
12921         }
12922       else
12923         {
12924           /* Array */
12925           return (cast
12926                   && (DECL_NAME (TYPE_NAME (source))
12927                       == java_lang_cloneable_identifier_node
12928                       || (DECL_NAME (TYPE_NAME (source))
12929                           == java_io_serializable_identifier_node)));
12930         }
12931     }
12932   if (TYPE_ARRAY_P (source))
12933     {
12934       if (TYPE_CLASS_P (dest))
12935         return dest == object_type_node;
12936       /* Can't cast an array to an interface unless the interface is
12937          java.lang.Cloneable or java.io.Serializable.  */
12938       if (TYPE_INTERFACE_P (dest))
12939         return (DECL_NAME (TYPE_NAME (dest))
12940                 == java_lang_cloneable_identifier_node
12941                 || (DECL_NAME (TYPE_NAME (dest))
12942                     == java_io_serializable_identifier_node));
12943       else                      /* Arrays */
12944         {
12945           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
12946           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
12947
12948           /* In case of severe errors, they turn out null */
12949           if (!dest_element_type || !source_element_type)
12950             return 0;
12951           if (source_element_type == dest_element_type)
12952             return 1;
12953           return valid_ref_assignconv_cast_p (source_element_type,
12954                                               dest_element_type, cast);
12955         }
12956       return 0;
12957     }
12958   return 0;
12959 }
12960
12961 static int
12962 valid_cast_to_p (tree source, tree dest)
12963 {
12964   if (TREE_CODE (source) == POINTER_TYPE)
12965     source = TREE_TYPE (source);
12966   if (TREE_CODE (dest) == POINTER_TYPE)
12967     dest = TREE_TYPE (dest);
12968
12969   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
12970     return valid_ref_assignconv_cast_p (source, dest, 1);
12971
12972   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
12973     return 1;
12974
12975   else if (TREE_CODE (source) == BOOLEAN_TYPE
12976            && TREE_CODE (dest) == BOOLEAN_TYPE)
12977     return 1;
12978
12979   return 0;
12980 }
12981
12982 static tree
12983 do_unary_numeric_promotion (tree arg)
12984 {
12985   tree type = TREE_TYPE (arg);
12986   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
12987       || TREE_CODE (type) == CHAR_TYPE)
12988     arg = convert (int_type_node, arg);
12989   return arg;
12990 }
12991
12992 /* Return a nonzero value if SOURCE can be converted into DEST using
12993    the method invocation conversion rule (5.3).  */
12994 static int
12995 valid_method_invocation_conversion_p (tree dest, tree source)
12996 {
12997   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
12998            && valid_builtin_assignconv_identity_widening_p (dest, source))
12999           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13000               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13001               && valid_ref_assignconv_cast_p (source, dest, 0)));
13002 }
13003
13004 /* Build an incomplete binop expression. */
13005
13006 static tree
13007 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13008 {
13009   tree binop = build2 (op, NULL_TREE, op1, op2);
13010   TREE_SIDE_EFFECTS (binop) = 1;
13011   /* Store the location of the operator, for better error report. The
13012      string of the operator will be rebuild based on the OP value. */
13013   EXPR_WFL_LINECOL (binop) = op_location;
13014   return binop;
13015 }
13016
13017 /* Build the string of the operator retained by NODE. If NODE is part
13018    of a compound expression, add an '=' at the end of the string. This
13019    function is called when an error needs to be reported on an
13020    operator. The string is returned as a pointer to a static character
13021    buffer. */
13022
13023 static char *
13024 operator_string (tree node)
13025 {
13026 #define BUILD_OPERATOR_STRING(S)                                        \
13027   {                                                                     \
13028     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13029     return buffer;                                                      \
13030   }
13031
13032   static char buffer [10];
13033   switch (TREE_CODE (node))
13034     {
13035     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13036     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13037     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13038     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13039     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13040     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13041     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13042     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13043     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13044     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13045     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13046     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13047     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13048     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13049     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13050     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13051     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13052     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13053     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13054     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13055     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13056     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13057     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13058     case PREINCREMENT_EXPR:     /* Fall through */
13059     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13060     case PREDECREMENT_EXPR:     /* Fall through */
13061     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13062     default:
13063       internal_error ("unregistered operator %s",
13064                       tree_code_name [TREE_CODE (node)]);
13065     }
13066   return NULL;
13067 #undef BUILD_OPERATOR_STRING
13068 }
13069
13070 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13071
13072 static int
13073 java_decl_equiv (tree var_acc1, tree var_acc2)
13074 {
13075   if (JDECL_P (var_acc1))
13076     return (var_acc1 == var_acc2);
13077
13078   return (TREE_CODE (var_acc1) == COMPONENT_REF
13079           && TREE_CODE (var_acc2) == COMPONENT_REF
13080           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13081              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13082           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13083 }
13084
13085 /* Return a nonzero value if CODE is one of the operators that can be
13086    used in conjunction with the `=' operator in a compound assignment.  */
13087
13088 static int
13089 binop_compound_p (enum tree_code code)
13090 {
13091   int i;
13092   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13093     if (binop_lookup [i] == code)
13094       break;
13095
13096   return i < BINOP_COMPOUND_CANDIDATES;
13097 }
13098
13099 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13100
13101 static tree
13102 java_refold (tree t)
13103 {
13104   tree c, b, ns, decl;
13105
13106   if (TREE_CODE (t) != MODIFY_EXPR)
13107     return t;
13108
13109   c = TREE_OPERAND (t, 1);
13110   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13111          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13112          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13113     return t;
13114
13115   /* Now the left branch of the binary operator. */
13116   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13117   if (! (b && TREE_CODE (b) == NOP_EXPR
13118          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13119     return t;
13120
13121   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13122   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13123          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13124     return t;
13125
13126   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13127   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13128       /* It's got to be the an equivalent decl */
13129       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13130     {
13131       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13132       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13133       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13134       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13135       /* Change the right part of the BINOP_EXPR */
13136       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13137     }
13138
13139   return t;
13140 }
13141
13142 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13143    errors but we modify NODE so that it contains the type computed
13144    according to the expression, when it's fixed. Otherwise, we write
13145    error_mark_node as the type. It allows us to further the analysis
13146    of remaining nodes and detects more errors in certain cases.  */
13147
13148 static tree
13149 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13150 {
13151   tree op1 = TREE_OPERAND (node, 0);
13152   tree op2 = TREE_OPERAND (node, 1);
13153   tree op1_type = TREE_TYPE (op1);
13154   tree op2_type = TREE_TYPE (op2);
13155   tree prom_type = NULL_TREE, cn;
13156   enum tree_code code = TREE_CODE (node);
13157
13158   /* If 1, tell the routine that we have to return error_mark_node
13159      after checking for the initialization of the RHS */
13160   int error_found = 0;
13161
13162   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13163
13164   /* If either op<n>_type are NULL, this might be early signs of an
13165      error situation, unless it's too early to tell (in case we're
13166      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13167      correctly so the error can be later on reported accurately. */
13168   if (! (code == PLUS_EXPR || code == NE_EXPR
13169          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13170     {
13171       tree n;
13172       if (! op1_type)
13173         {
13174           n = java_complete_tree (op1);
13175           op1_type = TREE_TYPE (n);
13176         }
13177       if (! op2_type)
13178         {
13179           n = java_complete_tree (op2);
13180           op2_type = TREE_TYPE (n);
13181         }
13182     }
13183
13184   switch (code)
13185     {
13186     /* 15.16 Multiplicative operators */
13187     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13188     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13189     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13190     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13191       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13192         {
13193           if (!JNUMERIC_TYPE_P (op1_type))
13194             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13195           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13196             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13197           TREE_TYPE (node) = error_mark_node;
13198           error_found = 1;
13199           break;
13200         }
13201       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13202
13203       /* Detect integral division by zero */
13204       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13205           && TREE_CODE (prom_type) == INTEGER_TYPE
13206           && (op2 == integer_zero_node || op2 == long_zero_node ||
13207               (TREE_CODE (op2) == INTEGER_CST &&
13208                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13209         {
13210           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13211           TREE_CONSTANT (node) = 0;
13212           TREE_INVARIANT (node) = 0;
13213         }
13214
13215       /* Change the division operator if necessary */
13216       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13217         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13218
13219       /* Before divisions as is disappear, try to simplify and bail if
13220          applicable, otherwise we won't perform even simple
13221          simplifications like (1-1)/3. We can't do that with floating
13222          point number, folds can't handle them at this stage. */
13223       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13224           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13225         {
13226           TREE_TYPE (node) = prom_type;
13227           node = fold (node);
13228           if (TREE_CODE (node) != code)
13229             return node;
13230         }
13231
13232       if (TREE_CODE (prom_type) == INTEGER_TYPE
13233           && flag_use_divide_subroutine
13234           && ! flag_emit_class_files
13235           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13236         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13237
13238       /* This one is more complicated. FLOATs are processed by a
13239          function call to soft_fmod. Duplicate the value of the
13240          COMPOUND_ASSIGN_P flag. */
13241       if (code == TRUNC_MOD_EXPR)
13242         {
13243           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13244           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13245           TREE_SIDE_EFFECTS (mod)
13246             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13247           return mod;
13248         }
13249       break;
13250
13251     /* 15.17 Additive Operators */
13252     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13253
13254       /* Operation is valid if either one argument is a string
13255          constant, a String object or a StringBuffer crafted for the
13256          purpose of the a previous usage of the String concatenation
13257          operator */
13258
13259       if (TREE_CODE (op1) == STRING_CST
13260           || TREE_CODE (op2) == STRING_CST
13261           || JSTRING_TYPE_P (op1_type)
13262           || JSTRING_TYPE_P (op2_type)
13263           || IS_CRAFTED_STRING_BUFFER_P (op1)
13264           || IS_CRAFTED_STRING_BUFFER_P (op2))
13265         return build_string_concatenation (op1, op2);
13266
13267     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13268                                    Numeric Types */
13269       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13270         {
13271           if (!JNUMERIC_TYPE_P (op1_type))
13272             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13273           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13274             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13275           TREE_TYPE (node) = error_mark_node;
13276           error_found = 1;
13277           break;
13278         }
13279       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13280       break;
13281
13282     /* 15.18 Shift Operators */
13283     case LSHIFT_EXPR:
13284     case RSHIFT_EXPR:
13285     case URSHIFT_EXPR:
13286       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13287         {
13288           if (!JINTEGRAL_TYPE_P (op1_type))
13289             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13290           else
13291             {
13292               if (JNUMERIC_TYPE_P (op2_type))
13293                 parse_error_context (wfl_operator,
13294                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13295                                      operator_string (node),
13296                                      lang_printable_name (op2_type, 0));
13297               else
13298                 parse_error_context (wfl_operator,
13299                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13300                                      operator_string (node),
13301                                      lang_printable_name (op2_type, 0));
13302             }
13303           TREE_TYPE (node) = error_mark_node;
13304           error_found = 1;
13305           break;
13306         }
13307
13308       /* Unary numeric promotion (5.6.1) is performed on each operand
13309          separately */
13310       op1 = do_unary_numeric_promotion (op1);
13311       op2 = do_unary_numeric_promotion (op2);
13312
13313       /* If the right hand side is of type `long', first cast it to
13314          `int'.  */
13315       if (TREE_TYPE (op2) == long_type_node)
13316         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13317
13318       /* The type of the shift expression is the type of the promoted
13319          type of the left-hand operand */
13320       prom_type = TREE_TYPE (op1);
13321
13322       /* Shift int only up to 0x1f and long up to 0x3f */
13323       if (prom_type == int_type_node)
13324         op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
13325                             build_int_2 (0x1f, 0)));
13326       else
13327         op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
13328                             build_int_2 (0x3f, 0)));
13329
13330       /* The >>> operator is a >> operating on unsigned quantities */
13331       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13332         {
13333           tree to_return;
13334           tree utype = java_unsigned_type (prom_type);
13335           op1 = convert (utype, op1);
13336           TREE_SET_CODE (node, RSHIFT_EXPR);
13337           TREE_OPERAND (node, 0) = op1;
13338           TREE_OPERAND (node, 1) = op2;
13339           TREE_TYPE (node) = utype;
13340           to_return = convert (prom_type, node);
13341           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13342           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13343           TREE_SIDE_EFFECTS (to_return)
13344             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13345           return to_return;
13346         }
13347       break;
13348
13349       /* 15.19.1 Type Comparison Operator instanceof */
13350     case INSTANCEOF_EXPR:
13351
13352       TREE_TYPE (node) = boolean_type_node;
13353
13354       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13355       if ((cn = patch_string (op1)))
13356         {
13357           op1 = cn;
13358           op1_type = TREE_TYPE (op1);
13359         }
13360       if (op1_type == NULL_TREE)
13361         abort ();
13362
13363       if (!(op2_type = resolve_type_during_patch (op2)))
13364         return error_mark_node;
13365
13366       /* The first operand must be a reference type or the null type */
13367       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13368         error_found = 1;        /* Error reported further below */
13369
13370       /* The second operand must be a reference type */
13371       if (!JREFERENCE_TYPE_P (op2_type))
13372         {
13373           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13374           parse_error_context
13375             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13376              lang_printable_name (op2_type, 0));
13377           error_found = 1;
13378         }
13379
13380       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13381         {
13382           /* If the first operand is null, the result is always false */
13383           if (op1 == null_pointer_node)
13384             return boolean_false_node;
13385           else if (flag_emit_class_files)
13386             {
13387               TREE_OPERAND (node, 1) = op2_type;
13388               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13389               return node;
13390             }
13391           /* Otherwise we have to invoke instance of to figure it out */
13392           else
13393             return build_instanceof (op1, op2_type);
13394         }
13395       /* There is no way the expression operand can be an instance of
13396          the type operand. This is a compile time error. */
13397       else
13398         {
13399           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13400           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13401           parse_error_context
13402             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13403              t1, lang_printable_name (op2_type, 0));
13404           free (t1);
13405           error_found = 1;
13406         }
13407
13408       break;
13409
13410       /* 15.21 Bitwise and Logical Operators */
13411     case BIT_AND_EXPR:
13412     case BIT_XOR_EXPR:
13413     case BIT_IOR_EXPR:
13414       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13415         /* Binary numeric promotion is performed on both operand and the
13416            expression retain that type */
13417         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13418
13419       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13420                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13421         /* The type of the bitwise operator expression is BOOLEAN */
13422         prom_type = boolean_type_node;
13423       else
13424         {
13425           if (!JINTEGRAL_TYPE_P (op1_type))
13426             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13427           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13428             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13429           TREE_TYPE (node) = error_mark_node;
13430           error_found = 1;
13431           /* Insert a break here if adding thing before the switch's
13432              break for this case */
13433         }
13434       break;
13435
13436       /* 15.22 Conditional-And Operator */
13437     case TRUTH_ANDIF_EXPR:
13438       /* 15.23 Conditional-Or Operator */
13439     case TRUTH_ORIF_EXPR:
13440       /* Operands must be of BOOLEAN type */
13441       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13442           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13443         {
13444           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13445             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13446           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13447             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13448           TREE_TYPE (node) = boolean_type_node;
13449           error_found = 1;
13450           break;
13451         }
13452       else if (integer_zerop (op1))
13453         {
13454           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13455         }
13456       else if (integer_onep (op1))
13457         {
13458           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13459         }
13460       /* The type of the conditional operators is BOOLEAN */
13461       prom_type = boolean_type_node;
13462       break;
13463
13464       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13465     case LT_EXPR:
13466     case GT_EXPR:
13467     case LE_EXPR:
13468     case GE_EXPR:
13469       /* The type of each of the operands must be a primitive numeric
13470          type */
13471       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13472         {
13473           if (!JNUMERIC_TYPE_P (op1_type))
13474             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13475           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13476             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13477           TREE_TYPE (node) = boolean_type_node;
13478           error_found = 1;
13479           break;
13480         }
13481       /* Binary numeric promotion is performed on the operands */
13482       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13483       /* The type of the relation expression is always BOOLEAN */
13484       prom_type = boolean_type_node;
13485       break;
13486
13487       /* 15.20 Equality Operator */
13488     case EQ_EXPR:
13489     case NE_EXPR:
13490       /* It's time for us to patch the strings. */
13491       if ((cn = patch_string (op1)))
13492        {
13493          op1 = cn;
13494          op1_type = TREE_TYPE (op1);
13495        }
13496       if ((cn = patch_string (op2)))
13497        {
13498          op2 = cn;
13499          op2_type = TREE_TYPE (op2);
13500        }
13501
13502       /* 15.20.1 Numerical Equality Operators == and != */
13503       /* Binary numeric promotion is performed on the operands */
13504       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13505         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13506
13507       /* 15.20.2 Boolean Equality Operators == and != */
13508       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13509           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13510         ;                       /* Nothing to do here */
13511
13512       /* 15.20.3 Reference Equality Operators == and != */
13513       /* Types have to be either references or the null type. If
13514          they're references, it must be possible to convert either
13515          type to the other by casting conversion. */
13516       else if (op1 == null_pointer_node || op2 == null_pointer_node
13517                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13518                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13519                        || valid_ref_assignconv_cast_p (op2_type,
13520                                                        op1_type, 1))))
13521         ;                       /* Nothing to do here */
13522
13523       /* Else we have an error figure what can't be converted into
13524          what and report the error */
13525       else
13526         {
13527           char *t1;
13528           t1 = xstrdup (lang_printable_name (op1_type, 0));
13529           parse_error_context
13530             (wfl_operator,
13531              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13532              operator_string (node), t1,
13533              lang_printable_name (op2_type, 0));
13534           free (t1);
13535           TREE_TYPE (node) = boolean_type_node;
13536           error_found = 1;
13537           break;
13538         }
13539       prom_type = boolean_type_node;
13540       break;
13541     default:
13542       abort ();
13543     }
13544
13545   if (error_found)
13546     return error_mark_node;
13547
13548   TREE_OPERAND (node, 0) = op1;
13549   TREE_OPERAND (node, 1) = op2;
13550   TREE_TYPE (node) = prom_type;
13551   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13552
13553   if (flag_emit_xref)
13554     return node;
13555
13556   /* fold does not respect side-effect order as required for Java but not C.
13557    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13558    * bytecode.
13559    */
13560   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13561       : ! TREE_SIDE_EFFECTS (node))
13562     node = fold (node);
13563   return node;
13564 }
13565
13566 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13567    zero value, the value of CSTE comes after the valude of STRING */
13568
13569 static tree
13570 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13571 {
13572   const char *old = TREE_STRING_POINTER (cste);
13573   int old_len = TREE_STRING_LENGTH (cste);
13574   int len = old_len + string_len;
13575   char *new = alloca (len+1);
13576
13577   if (after)
13578     {
13579       memcpy (new, string, string_len);
13580       memcpy (&new [string_len], old, old_len);
13581     }
13582   else
13583     {
13584       memcpy (new, old, old_len);
13585       memcpy (&new [old_len], string, string_len);
13586     }
13587   new [len] = '\0';
13588   return build_string (len, new);
13589 }
13590
13591 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13592    new STRING_CST on success, NULL_TREE on failure.  */
13593
13594 static tree
13595 merge_string_cste (tree op1, tree op2, int after)
13596 {
13597   /* Handle two string constants right away.  */
13598   if (TREE_CODE (op2) == STRING_CST)
13599     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13600                                  TREE_STRING_LENGTH (op2), after);
13601
13602   /* Reasonable integer constant can be treated right away.  */
13603   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13604     {
13605       static const char *const boolean_true = "true";
13606       static const char *const boolean_false = "false";
13607       static const char *const null_pointer = "null";
13608       char ch[4];
13609       const char *string;
13610
13611       if (op2 == boolean_true_node)
13612         string = boolean_true;
13613       else if (op2 == boolean_false_node)
13614         string = boolean_false;
13615       else if (op2 == null_pointer_node
13616                || (integer_zerop (op2)
13617                    && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
13618         /* FIXME: null is not a compile-time constant, so it is only safe to
13619            merge if the overall expression is non-constant. However, this
13620            code always merges without checking the overall expression.  */
13621         string = null_pointer;
13622       else if (TREE_TYPE (op2) == char_type_node)
13623         {
13624           /* Convert the character into UTF-8.  */
13625           unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13626           unsigned char *p = (unsigned char *) ch;
13627           if (0x01 <= c && c <= 0x7f)
13628             *p++ = (unsigned char) c;
13629           else if (c < 0x7ff)
13630             {
13631               *p++ = (unsigned char) (c >> 6 | 0xc0);
13632               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13633             }
13634           else
13635             {
13636               *p++ = (unsigned char) (c >> 12 | 0xe0);
13637               *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13638               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13639             }
13640           *p = '\0';
13641
13642           string = ch;
13643         }
13644       else
13645         string = string_convert_int_cst (op2);
13646
13647       return do_merge_string_cste (op1, string, strlen (string), after);
13648     }
13649   return NULL_TREE;
13650 }
13651
13652 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13653    has to be a STRING_CST and the other part must be a STRING_CST or a
13654    INTEGRAL constant. Return a new STRING_CST if the operation
13655    succeed, NULL_TREE otherwise.
13656
13657    If the case we want to optimize for space, we might want to return
13658    NULL_TREE for each invocation of this routine. FIXME */
13659
13660 static tree
13661 string_constant_concatenation (tree op1, tree op2)
13662 {
13663   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13664     {
13665       tree string, rest;
13666       int invert;
13667
13668       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13669       rest   = (string == op1 ? op2 : op1);
13670       invert = (string == op1 ? 0 : 1 );
13671
13672       /* Walk REST, only if it looks reasonable */
13673       if (TREE_CODE (rest) != STRING_CST
13674           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13675           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13676           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13677         {
13678           rest = java_complete_tree (rest);
13679           if (rest == error_mark_node)
13680             return error_mark_node;
13681           rest = fold (rest);
13682         }
13683       return merge_string_cste (string, rest, invert);
13684     }
13685   return NULL_TREE;
13686 }
13687
13688 /* Implement the `+' operator. Does static optimization if possible,
13689    otherwise create (if necessary) and append elements to a
13690    StringBuffer. The StringBuffer will be carried around until it is
13691    used for a function call or an assignment. Then toString() will be
13692    called on it to turn it into a String object. */
13693
13694 static tree
13695 build_string_concatenation (tree op1, tree op2)
13696 {
13697   tree result;
13698   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13699
13700   if (flag_emit_xref)
13701     return build2 (PLUS_EXPR, string_type_node, op1, op2);
13702
13703   /* Try to do some static optimization */
13704   if ((result = string_constant_concatenation (op1, op2)))
13705     return result;
13706
13707   /* Discard empty strings on either side of the expression */
13708   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13709     {
13710       op1 = op2;
13711       op2 = NULL_TREE;
13712     }
13713   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13714     op2 = NULL_TREE;
13715
13716   /* If operands are string constant, turn then into object references */
13717   if (TREE_CODE (op1) == STRING_CST)
13718     op1 = patch_string_cst (op1);
13719   if (op2 && TREE_CODE (op2) == STRING_CST)
13720     op2 = patch_string_cst (op2);
13721
13722   /* If either one of the constant is null and the other non null
13723      operand is a String constant, return it. */
13724   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13725     return op1;
13726
13727   /* If OP1 isn't already a StringBuffer, create and
13728      initialize a new one */
13729   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13730     {
13731       /* Two solutions here:
13732          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13733          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13734       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13735         op1 = BUILD_STRING_BUFFER (op1);
13736       else
13737         {
13738           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13739           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13740         }
13741     }
13742
13743   if (op2)
13744     {
13745       /* OP1 is no longer the last node holding a crafted StringBuffer */
13746       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13747       /* Create a node for `{new...,xxx}.append (op2)' */
13748       if (op2)
13749         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13750     }
13751
13752   /* Mark the last node holding a crafted StringBuffer */
13753   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13754
13755   TREE_SIDE_EFFECTS (op1) = side_effects;
13756   return op1;
13757 }
13758
13759 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13760    StringBuffer. If no string were found to be patched, return
13761    NULL. */
13762
13763 static tree
13764 patch_string (tree node)
13765 {
13766   if (node == error_mark_node)
13767     return error_mark_node;
13768   if (TREE_CODE (node) == STRING_CST)
13769     return patch_string_cst (node);
13770   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13771     {
13772       int saved = ctxp->explicit_constructor_p;
13773       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13774       tree ret;
13775       /* Temporary disable forbid the use of `this'. */
13776       ctxp->explicit_constructor_p = 0;
13777       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13778       /* String concatenation arguments must be evaluated in order too. */
13779       ret = force_evaluation_order (ret);
13780       /* Restore it at its previous value */
13781       ctxp->explicit_constructor_p = saved;
13782       return ret;
13783     }
13784   return NULL_TREE;
13785 }
13786
13787 /* Build the internal representation of a string constant.  */
13788
13789 static tree
13790 patch_string_cst (tree node)
13791 {
13792   int location;
13793   if (! flag_emit_class_files)
13794     {
13795       node = get_identifier (TREE_STRING_POINTER (node));
13796       location = alloc_name_constant (CONSTANT_String, node);
13797       node = build_ref_from_constant_pool (location);
13798     }
13799   TREE_CONSTANT (node) = 1;
13800   TREE_INVARIANT (node) = 1;
13801
13802   /* ??? Guessing that the class file code can't handle casts.  */
13803   if (! flag_emit_class_files)
13804     node = convert (string_ptr_type_node, node);
13805   else
13806     TREE_TYPE (node) = string_ptr_type_node;
13807
13808   return node;
13809 }
13810
13811 /* Build an incomplete unary operator expression. */
13812
13813 static tree
13814 build_unaryop (int op_token, int op_location, tree op1)
13815 {
13816   enum tree_code op;
13817   tree unaryop;
13818   switch (op_token)
13819     {
13820     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13821     case MINUS_TK: op = NEGATE_EXPR; break;
13822     case NEG_TK: op = TRUTH_NOT_EXPR; break;
13823     case NOT_TK: op = BIT_NOT_EXPR; break;
13824     default: abort ();
13825     }
13826
13827   unaryop = build1 (op, NULL_TREE, op1);
13828   TREE_SIDE_EFFECTS (unaryop) = 1;
13829   /* Store the location of the operator, for better error report. The
13830      string of the operator will be rebuild based on the OP value. */
13831   EXPR_WFL_LINECOL (unaryop) = op_location;
13832   return unaryop;
13833 }
13834
13835 /* Special case for the ++/-- operators, since they require an extra
13836    argument to build, which is set to NULL and patched
13837    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
13838
13839 static tree
13840 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
13841 {
13842   static const enum tree_code lookup [2][2] =
13843     {
13844       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
13845       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
13846     };
13847   tree node = build2 (lookup [is_post_p][(op_token - DECR_TK)],
13848                       NULL_TREE, op1, NULL_TREE);
13849   TREE_SIDE_EFFECTS (node) = 1;
13850   /* Store the location of the operator, for better error report. The
13851      string of the operator will be rebuild based on the OP value. */
13852   EXPR_WFL_LINECOL (node) = op_location;
13853   return node;
13854 }
13855
13856 /* Build an incomplete cast operator, based on the use of the
13857    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13858    set. java_complete_tree is trained to walk a CONVERT_EXPR even
13859    though its type is already set.  */
13860
13861 static tree
13862 build_cast (int location, tree type, tree exp)
13863 {
13864   tree node = build1 (CONVERT_EXPR, type, exp);
13865   EXPR_WFL_LINECOL (node) = location;
13866   return node;
13867 }
13868
13869 /* Build an incomplete class reference operator.  */
13870 static tree
13871 build_incomplete_class_ref (int location, tree class_name)
13872 {
13873   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13874   tree class_decl = GET_CPC ();
13875   tree this_class = TREE_TYPE (class_decl);
13876
13877   /* Generate the synthetic static method `class$'.  (Previously we
13878      deferred this, causing different method tables to be emitted
13879      for native code and bytecode.)  */
13880   if (!TYPE_DOT_CLASS (this_class)
13881       && !JPRIMITIVE_TYPE_P (class_name)
13882       && !(TREE_CODE (class_name) == VOID_TYPE))
13883     {
13884       tree cpc_list = GET_CPC_LIST();
13885       tree cpc = cpc_list;
13886       tree target_class;
13887
13888       /* For inner classes, add a 'class$' method to their outermost
13889          context, creating it if necessary.  */
13890
13891       while (GET_NEXT_ENCLOSING_CPC(cpc))
13892         cpc = GET_NEXT_ENCLOSING_CPC(cpc);
13893       class_decl = TREE_VALUE (cpc);
13894
13895       target_class = TREE_TYPE (class_decl);
13896
13897       if (CLASS_INTERFACE (TYPE_NAME (target_class)))
13898         {
13899           /* For interfaces, adding a static 'class$' method directly
13900              is illegal.  So create an inner class to contain the new
13901              method.  Empirically this matches the behavior of javac.  */
13902           tree t, inner;
13903           /* We want the generated inner class inside the outermost class. */
13904           GET_CPC_LIST() = cpc;
13905           t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
13906           inner = create_anonymous_class (t);
13907           target_class = TREE_TYPE (inner);
13908           end_class_declaration (1);
13909           GET_CPC_LIST() = cpc_list;
13910         }
13911
13912       if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
13913         build_dot_class_method (target_class);
13914
13915       if (this_class != target_class)
13916         TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
13917     }
13918
13919   EXPR_WFL_LINECOL (node) = location;
13920   return node;
13921 }
13922
13923 /* Complete an incomplete class reference operator.  */
13924 static tree
13925 patch_incomplete_class_ref (tree node)
13926 {
13927   tree type = TREE_OPERAND (node, 0);
13928   tree ref_type;
13929
13930   if (!(ref_type = resolve_type_during_patch (type)))
13931     return error_mark_node;
13932
13933   /* If we're not emitting class files and we know ref_type is a
13934      compiled class, build a direct reference.  */
13935   if ((! flag_emit_class_files && is_compiled_class (ref_type))
13936       || JPRIMITIVE_TYPE_P (ref_type)
13937       || TREE_CODE (ref_type) == VOID_TYPE)
13938     {
13939       tree dot = build_class_ref (ref_type);
13940       /* A class referenced by `foo.class' is initialized.  */
13941       if (!flag_emit_class_files)
13942        dot = build_class_init (ref_type, dot);
13943       return java_complete_tree (dot);
13944     }
13945
13946   /* If we're emitting class files and we have to deal with non
13947      primitive types, we invoke the synthetic static method `class$'.  */
13948   ref_type = build_dot_class_method_invocation (current_class, ref_type);
13949   return java_complete_tree (ref_type);
13950 }
13951
13952 /* 15.14 Unary operators. We return error_mark_node in case of error,
13953    but preserve the type of NODE if the type is fixed.  */
13954
13955 static tree
13956 patch_unaryop (tree node, tree wfl_op)
13957 {
13958   tree op = TREE_OPERAND (node, 0);
13959   tree op_type = TREE_TYPE (op);
13960   tree prom_type = NULL_TREE, value, decl;
13961   int outer_field_flag = 0;
13962   int code = TREE_CODE (node);
13963   int error_found = 0;
13964
13965   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13966
13967   switch (code)
13968     {
13969       /* 15.13.2 Postfix Increment Operator ++ */
13970     case POSTINCREMENT_EXPR:
13971       /* 15.13.3 Postfix Increment Operator -- */
13972     case POSTDECREMENT_EXPR:
13973       /* 15.14.1 Prefix Increment Operator ++ */
13974     case PREINCREMENT_EXPR:
13975       /* 15.14.2 Prefix Decrement Operator -- */
13976     case PREDECREMENT_EXPR:
13977       op = decl = strip_out_static_field_access_decl (op);
13978       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
13979       /* We might be trying to change an outer field accessed using
13980          access method. */
13981       if (outer_field_flag)
13982         {
13983           /* Retrieve the decl of the field we're trying to access. We
13984              do that by first retrieving the function we would call to
13985              access the field. It has been already verified that this
13986              field isn't final */
13987           if (flag_emit_class_files)
13988             decl = TREE_OPERAND (op, 0);
13989           else
13990             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
13991           decl = DECL_FUNCTION_ACCESS_DECL (decl);
13992         }
13993       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
13994       else if (!JDECL_P (decl)
13995           && TREE_CODE (decl) != COMPONENT_REF
13996           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
13997           && TREE_CODE (decl) != INDIRECT_REF
13998           && !(TREE_CODE (decl) == COMPOUND_EXPR
13999                && TREE_OPERAND (decl, 1)
14000                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14001         {
14002           TREE_TYPE (node) = error_mark_node;
14003           error_found = 1;
14004         }
14005
14006       /* From now on, we know that op if a variable and that it has a
14007          valid wfl. We use wfl_op to locate errors related to the
14008          ++/-- operand. */
14009       if (!JNUMERIC_TYPE_P (op_type))
14010         {
14011           parse_error_context
14012             (wfl_op, "Invalid argument type `%s' to `%s'",
14013              lang_printable_name (op_type, 0), operator_string (node));
14014           TREE_TYPE (node) = error_mark_node;
14015           error_found = 1;
14016         }
14017       else
14018         {
14019           /* Before the addition, binary numeric promotion is performed on
14020              both operands, if really necessary */
14021           if (JINTEGRAL_TYPE_P (op_type))
14022             {
14023               value = build_int_2 (1, 0);
14024               TREE_TYPE (value) = TREE_TYPE (node) = op_type;
14025             }
14026           else
14027             {
14028               value = build_int_2 (1, 0);
14029               TREE_TYPE (node) =
14030                 binary_numeric_promotion (op_type,
14031                                           TREE_TYPE (value), &op, &value);
14032             }
14033
14034           /* We remember we might be accessing an outer field */
14035           if (outer_field_flag)
14036             {
14037               /* We re-generate an access to the field */
14038               value = build2 (PLUS_EXPR, TREE_TYPE (op),
14039                               build_outer_field_access (wfl_op, decl), value);
14040
14041               /* And we patch the original access$() into a write
14042                  with plus_op as a rhs */
14043               return outer_field_access_fix (node, op, value);
14044             }
14045
14046           /* And write back into the node. */
14047           TREE_OPERAND (node, 0) = op;
14048           TREE_OPERAND (node, 1) = value;
14049           /* Convert the overall back into its original type, if
14050              necessary, and return */
14051           if (JINTEGRAL_TYPE_P (op_type))
14052             return fold (node);
14053           else
14054             return fold (convert (op_type, node));
14055         }
14056       break;
14057
14058       /* 15.14.3 Unary Plus Operator + */
14059     case UNARY_PLUS_EXPR:
14060       /* 15.14.4 Unary Minus Operator - */
14061     case NEGATE_EXPR:
14062       if (!JNUMERIC_TYPE_P (op_type))
14063         {
14064           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14065           TREE_TYPE (node) = error_mark_node;
14066           error_found = 1;
14067         }
14068       /* Unary numeric promotion is performed on operand */
14069       else
14070         {
14071           op = do_unary_numeric_promotion (op);
14072           prom_type = TREE_TYPE (op);
14073           if (code == UNARY_PLUS_EXPR)
14074             return fold (op);
14075         }
14076       break;
14077
14078       /* 15.14.5 Bitwise Complement Operator ~ */
14079     case BIT_NOT_EXPR:
14080       if (!JINTEGRAL_TYPE_P (op_type))
14081         {
14082           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14083           TREE_TYPE (node) = error_mark_node;
14084           error_found = 1;
14085         }
14086       else
14087         {
14088           op = do_unary_numeric_promotion (op);
14089           prom_type = TREE_TYPE (op);
14090         }
14091       break;
14092
14093       /* 15.14.6 Logical Complement Operator ! */
14094     case TRUTH_NOT_EXPR:
14095       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14096         {
14097           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14098           /* But the type is known. We will report an error if further
14099              attempt of a assignment is made with this rhs */
14100           TREE_TYPE (node) = boolean_type_node;
14101           error_found = 1;
14102         }
14103       else
14104         prom_type = boolean_type_node;
14105       break;
14106
14107       /* 15.15 Cast Expression */
14108     case CONVERT_EXPR:
14109       value = patch_cast (node, wfl_operator);
14110       if (value == error_mark_node)
14111         {
14112           /* If this cast is part of an assignment, we tell the code
14113              that deals with it not to complain about a mismatch,
14114              because things have been cast, anyways */
14115           TREE_TYPE (node) = error_mark_node;
14116           error_found = 1;
14117         }
14118       else
14119         {
14120           value = fold (value);
14121           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14122           return value;
14123         }
14124       break;
14125     }
14126
14127   if (error_found)
14128     return error_mark_node;
14129
14130   /* There are cases where node has been replaced by something else
14131      and we don't end up returning here: UNARY_PLUS_EXPR,
14132      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14133   TREE_OPERAND (node, 0) = fold (op);
14134   TREE_TYPE (node) = prom_type;
14135   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14136   return fold (node);
14137 }
14138
14139 /* Generic type resolution that sometimes takes place during node
14140    patching. Returned the resolved type or generate an error
14141    message. Return the resolved type or NULL_TREE.  */
14142
14143 static tree
14144 resolve_type_during_patch (tree type)
14145 {
14146   if (unresolved_type_p (type, NULL))
14147     {
14148       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14149       if (!type_decl)
14150         {
14151           parse_error_context (type,
14152                                "Class `%s' not found in type declaration",
14153                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14154           return NULL_TREE;
14155         }
14156
14157       check_deprecation (type, type_decl);
14158
14159       return TREE_TYPE (type_decl);
14160     }
14161   return type;
14162 }
14163
14164 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14165    found. Otherwise NODE or something meant to replace it is returned.  */
14166
14167 static tree
14168 patch_cast (tree node, tree wfl_op)
14169 {
14170   tree op = TREE_OPERAND (node, 0);
14171   tree cast_type = TREE_TYPE (node);
14172   tree patched, op_type;
14173   char *t1;
14174
14175   /* Some string patching might be necessary at this stage */
14176   if ((patched = patch_string (op)))
14177     TREE_OPERAND (node, 0) = op = patched;
14178   op_type = TREE_TYPE (op);
14179
14180   /* First resolve OP_TYPE if unresolved */
14181   if (!(cast_type = resolve_type_during_patch (cast_type)))
14182     return error_mark_node;
14183
14184   /* Check on cast that are proven correct at compile time */
14185   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14186     {
14187       /* Same type */
14188       if (cast_type == op_type)
14189         return node;
14190
14191       /* A narrowing conversion from a floating-point number to an
14192          integral type requires special handling (5.1.3).  */
14193       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14194         if (cast_type != long_type_node)
14195           op = convert (integer_type_node, op);
14196
14197       /* Try widening/narrowing conversion.  Potentially, things need
14198          to be worked out in gcc so we implement the extreme cases
14199          correctly.  fold_convert() needs to be fixed.  */
14200       return convert (cast_type, op);
14201     }
14202
14203   /* It's also valid to cast a boolean into a boolean */
14204   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14205     return node;
14206
14207   /* null can be casted to references */
14208   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14209     return build_null_of_type (cast_type);
14210
14211   /* The remaining legal casts involve conversion between reference
14212      types. Check for their compile time correctness. */
14213   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14214       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14215     {
14216       TREE_TYPE (node) = promote_type (cast_type);
14217       /* Now, the case can be determined correct at compile time if
14218          OP_TYPE can be converted into CAST_TYPE by assignment
14219          conversion (5.2) */
14220
14221       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14222         {
14223           TREE_SET_CODE (node, NOP_EXPR);
14224           return node;
14225         }
14226
14227       if (flag_emit_class_files)
14228         {
14229           TREE_SET_CODE (node, CONVERT_EXPR);
14230           return node;
14231         }
14232
14233       /* The cast requires a run-time check */
14234       return build3 (CALL_EXPR, promote_type (cast_type),
14235                      build_address_of (soft_checkcast_node),
14236                      tree_cons (NULL_TREE, build_class_ref (cast_type),
14237                                 build_tree_list (NULL_TREE, op)),
14238                      NULL_TREE);
14239     }
14240
14241   /* Any other casts are proven incorrect at compile time */
14242   t1 = xstrdup (lang_printable_name (op_type, 0));
14243   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14244                        t1, lang_printable_name (cast_type, 0));
14245   free (t1);
14246   return error_mark_node;
14247 }
14248
14249 /* Build a null constant and give it the type TYPE.  */
14250
14251 static tree
14252 build_null_of_type (tree type)
14253 {
14254   tree node = build_int_2 (0, 0);
14255   TREE_TYPE (node) = promote_type (type);
14256   return node;
14257 }
14258
14259 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14260    a list of indices. */
14261 static tree
14262 build_array_ref (int location, tree array, tree index)
14263 {
14264   tree node = build4 (ARRAY_REF, NULL_TREE, array, index,
14265                       NULL_TREE, NULL_TREE);
14266   EXPR_WFL_LINECOL (node) = location;
14267   return node;
14268 }
14269
14270 /* 15.12 Array Access Expression */
14271
14272 static tree
14273 patch_array_ref (tree node)
14274 {
14275   tree array = TREE_OPERAND (node, 0);
14276   tree array_type  = TREE_TYPE (array);
14277   tree index = TREE_OPERAND (node, 1);
14278   tree index_type = TREE_TYPE (index);
14279   int error_found = 0;
14280
14281   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14282
14283   if (TREE_CODE (array_type) == POINTER_TYPE)
14284     array_type = TREE_TYPE (array_type);
14285
14286   /* The array reference must be an array */
14287   if (!TYPE_ARRAY_P (array_type))
14288     {
14289       parse_error_context
14290         (wfl_operator,
14291          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14292          lang_printable_name (array_type, 0));
14293       TREE_TYPE (node) = error_mark_node;
14294       error_found = 1;
14295     }
14296
14297   /* The array index undergoes unary numeric promotion. The promoted
14298      type must be int */
14299   index = do_unary_numeric_promotion (index);
14300   if (TREE_TYPE (index) != int_type_node)
14301     {
14302       if (valid_cast_to_p (index_type, int_type_node))
14303         parse_error_context (wfl_operator,
14304    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14305                              lang_printable_name (index_type, 0));
14306       else
14307         parse_error_context (wfl_operator,
14308           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14309                              lang_printable_name (index_type, 0));
14310       TREE_TYPE (node) = error_mark_node;
14311       error_found = 1;
14312     }
14313
14314   if (error_found)
14315     return error_mark_node;
14316
14317   array_type = TYPE_ARRAY_ELEMENT (array_type);
14318
14319   if (flag_emit_class_files || flag_emit_xref)
14320     {
14321       TREE_OPERAND (node, 0) = array;
14322       TREE_OPERAND (node, 1) = index;
14323     }
14324   else
14325     node = build_java_arrayaccess (array, array_type, index);
14326   TREE_TYPE (node) = array_type;
14327   return node;
14328 }
14329
14330 /* 15.9 Array Creation Expressions */
14331
14332 static tree
14333 build_newarray_node (tree type, tree dims, int extra_dims)
14334 {
14335   tree node = build3 (NEW_ARRAY_EXPR, NULL_TREE, type,
14336                       nreverse (dims), build_int_2 (extra_dims, 0));
14337   return node;
14338 }
14339
14340 static tree
14341 patch_newarray (tree node)
14342 {
14343   tree type = TREE_OPERAND (node, 0);
14344   tree dims = TREE_OPERAND (node, 1);
14345   tree cdim, array_type;
14346   int error_found = 0;
14347   int ndims = 0;
14348   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14349
14350   /* Dimension types are verified. It's better for the types to be
14351      verified in order. */
14352   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14353     {
14354       int dim_error = 0;
14355       tree dim = TREE_VALUE (cdim);
14356
14357       /* Dim might have been saved during its evaluation */
14358       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14359
14360       /* The type of each specified dimension must be an integral type. */
14361       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14362         dim_error = 1;
14363
14364       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14365          promoted type must be int. */
14366       else
14367         {
14368           dim = do_unary_numeric_promotion (dim);
14369           if (TREE_TYPE (dim) != int_type_node)
14370             dim_error = 1;
14371         }
14372
14373       /* Report errors on types here */
14374       if (dim_error)
14375         {
14376           parse_error_context
14377             (TREE_PURPOSE (cdim),
14378              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14379              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14380               "Explicit cast needed to" : "Can't"),
14381              lang_printable_name (TREE_TYPE (dim), 0));
14382           error_found = 1;
14383         }
14384
14385       TREE_PURPOSE (cdim) = NULL_TREE;
14386     }
14387
14388   /* Resolve array base type if unresolved */
14389   if (!(type = resolve_type_during_patch (type)))
14390     error_found = 1;
14391
14392   if (error_found)
14393     {
14394       /* We don't want further evaluation of this bogus array creation
14395          operation */
14396       TREE_TYPE (node) = error_mark_node;
14397       return error_mark_node;
14398     }
14399
14400   /* Set array_type to the actual (promoted) array type of the result. */
14401   if (TREE_CODE (type) == RECORD_TYPE)
14402     type = build_pointer_type (type);
14403   while (--xdims >= 0)
14404     {
14405       type = promote_type (build_java_array_type (type, -1));
14406     }
14407   dims = nreverse (dims);
14408   array_type = type;
14409   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14410     {
14411       type = array_type;
14412       array_type
14413         = build_java_array_type (type,
14414                                  TREE_CODE (cdim) == INTEGER_CST
14415                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14416                                  : -1);
14417       array_type = promote_type (array_type);
14418     }
14419   dims = nreverse (dims);
14420
14421   /* The node is transformed into a function call. Things are done
14422      differently according to the number of dimensions. If the number
14423      of dimension is equal to 1, then the nature of the base type
14424      (primitive or not) matters. */
14425   if (ndims == 1)
14426     return build_new_array (type, TREE_VALUE (dims));
14427
14428   /* Can't reuse what's already written in expr.c because it uses the
14429      JVM stack representation. Provide a build_multianewarray. FIXME */
14430   return build3 (CALL_EXPR, array_type,
14431                  build_address_of (soft_multianewarray_node),
14432                  tree_cons (NULL_TREE,
14433                             build_class_ref (TREE_TYPE (array_type)),
14434                             tree_cons (NULL_TREE,
14435                                        build_int_2 (ndims, 0), dims )),
14436                  NULL_TREE);
14437 }
14438
14439 /* 10.6 Array initializer.  */
14440
14441 /* Build a wfl for array element that don't have one, so we can
14442    pin-point errors.  */
14443
14444 static tree
14445 maybe_build_array_element_wfl (tree node)
14446 {
14447   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14448     return build_expr_wfl (NULL_TREE, ctxp->filename,
14449                            ctxp->elc.line, ctxp->elc.prev_col);
14450   else
14451     return NULL_TREE;
14452 }
14453
14454 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14455    identification of initialized arrays easier to detect during walk
14456    and expansion.  */
14457
14458 static tree
14459 build_new_array_init (int location, tree values)
14460 {
14461   tree constructor = build_constructor (NULL_TREE, values);
14462   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14463   EXPR_WFL_LINECOL (to_return) = location;
14464   return to_return;
14465 }
14466
14467 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14468    occurred.  Otherwise return NODE after having set its type
14469    appropriately.  */
14470
14471 static tree
14472 patch_new_array_init (tree type, tree node)
14473 {
14474   int error_seen = 0;
14475   tree current, element_type;
14476   HOST_WIDE_INT length;
14477   int all_constant = 1;
14478   tree init = TREE_OPERAND (node, 0);
14479
14480   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14481     {
14482       parse_error_context (node,
14483                            "Invalid array initializer for non-array type `%s'",
14484                            lang_printable_name (type, 1));
14485       return error_mark_node;
14486     }
14487   type = TREE_TYPE (type);
14488   element_type = TYPE_ARRAY_ELEMENT (type);
14489
14490   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14491
14492   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14493        current;  length++, current = TREE_CHAIN (current))
14494     {
14495       tree elt = TREE_VALUE (current);
14496       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14497         {
14498           error_seen |= array_constructor_check_entry (element_type, current);
14499           elt = TREE_VALUE (current);
14500           /* When compiling to native code, STRING_CST is converted to
14501              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14502           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14503             all_constant = 0;
14504         }
14505       else
14506         {
14507           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14508           TREE_PURPOSE (current) = NULL_TREE;
14509           all_constant = 0;
14510         }
14511       if (elt && TREE_CODE (elt) == TREE_LIST
14512           && TREE_VALUE (elt) == error_mark_node)
14513         error_seen = 1;
14514     }
14515
14516   if (error_seen)
14517     return error_mark_node;
14518
14519   /* Create a new type. We can't reuse the one we have here by
14520      patching its dimension because it originally is of dimension -1
14521      hence reused by gcc. This would prevent triangular arrays. */
14522   type = build_java_array_type (element_type, length);
14523   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14524   TREE_TYPE (node) = promote_type (type);
14525   TREE_CONSTANT (init) = all_constant;
14526   TREE_INVARIANT (init) = all_constant;
14527   TREE_CONSTANT (node) = all_constant;
14528   TREE_INVARIANT (node) = all_constant;
14529   return node;
14530 }
14531
14532 /* Verify that one entry of the initializer element list can be
14533    assigned to the array base type. Report 1 if an error occurred, 0
14534    otherwise.  */
14535
14536 static int
14537 array_constructor_check_entry (tree type, tree entry)
14538 {
14539   char *array_type_string = NULL;       /* For error reports */
14540   tree value, type_value, new_value, wfl_value, patched;
14541   int error_seen = 0;
14542
14543   new_value = NULL_TREE;
14544   wfl_value = TREE_VALUE (entry);
14545
14546   value = java_complete_tree (TREE_VALUE (entry));
14547   /* patch_string return error_mark_node if arg is error_mark_node */
14548   if ((patched = patch_string (value)))
14549     value = patched;
14550   if (value == error_mark_node)
14551     return 1;
14552
14553   type_value = TREE_TYPE (value);
14554
14555   /* At anytime, try_builtin_assignconv can report a warning on
14556      constant overflow during narrowing. */
14557   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14558   new_value = try_builtin_assignconv (wfl_operator, type, value);
14559   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14560     type_value = promote_type (type);
14561
14562   /* Check and report errors */
14563   if (!new_value)
14564     {
14565       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14566                    "Can't" : "Explicit cast needed to");
14567       if (!array_type_string)
14568         array_type_string = xstrdup (lang_printable_name (type, 1));
14569       parse_error_context
14570         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14571          msg, lang_printable_name (type_value, 1), array_type_string);
14572       error_seen = 1;
14573     }
14574
14575   if (new_value)
14576     TREE_VALUE (entry) = new_value;
14577
14578   if (array_type_string)
14579     free (array_type_string);
14580
14581   TREE_PURPOSE (entry) = NULL_TREE;
14582   return error_seen;
14583 }
14584
14585 static tree
14586 build_this (int location)
14587 {
14588   tree node = build_wfl_node (this_identifier_node);
14589   TREE_SET_CODE (node, THIS_EXPR);
14590   EXPR_WFL_LINECOL (node) = location;
14591   return node;
14592 }
14593
14594 /* 14.15 The return statement. It builds a modify expression that
14595    assigns the returned value to the RESULT_DECL that hold the value
14596    to be returned. */
14597
14598 static tree
14599 build_return (int location, tree op)
14600 {
14601   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14602   EXPR_WFL_LINECOL (node) = location;
14603   node = build_debugable_stmt (location, node);
14604   return node;
14605 }
14606
14607 static tree
14608 patch_return (tree node)
14609 {
14610   tree return_exp = TREE_OPERAND (node, 0);
14611   tree meth = current_function_decl;
14612   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14613   int error_found = 0;
14614
14615   TREE_TYPE (node) = error_mark_node;
14616   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14617
14618   /* It's invalid to have a return value within a function that is
14619      declared with the keyword void or that is a constructor */
14620   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14621     error_found = 1;
14622
14623   /* It's invalid to use a return statement in a static block */
14624   if (DECL_CLINIT_P (current_function_decl))
14625     error_found = 1;
14626
14627   /* It's invalid to have a no return value within a function that
14628      isn't declared with the keyword `void' */
14629   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14630     error_found = 2;
14631
14632   if (DECL_INSTINIT_P (current_function_decl))
14633     error_found = 1;
14634
14635   if (error_found)
14636     {
14637       if (DECL_INSTINIT_P (current_function_decl))
14638         parse_error_context (wfl_operator,
14639                              "`return' inside instance initializer");
14640
14641       else if (DECL_CLINIT_P (current_function_decl))
14642         parse_error_context (wfl_operator,
14643                              "`return' inside static initializer");
14644
14645       else if (!DECL_CONSTRUCTOR_P (meth))
14646         {
14647           char *t = xstrdup (lang_printable_name (mtype, 0));
14648           parse_error_context (wfl_operator,
14649                                "`return' with%s value from `%s %s'",
14650                                (error_found == 1 ? "" : "out"),
14651                                t, lang_printable_name (meth, 0));
14652           free (t);
14653         }
14654       else
14655         parse_error_context (wfl_operator,
14656                              "`return' with value from constructor `%s'",
14657                              lang_printable_name (meth, 0));
14658       return error_mark_node;
14659     }
14660
14661   /* If we have a return_exp, build a modify expression and expand
14662      it. Note: at that point, the assignment is declared valid, but we
14663      may want to carry some more hacks */
14664   if (return_exp)
14665     {
14666       tree exp = java_complete_tree (return_exp);
14667       tree modify, patched;
14668
14669       if ((patched = patch_string (exp)))
14670         exp = patched;
14671
14672       modify = build2 (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14673       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14674       modify = java_complete_tree (modify);
14675
14676       if (modify != error_mark_node)
14677         {
14678           TREE_SIDE_EFFECTS (modify) = 1;
14679           TREE_OPERAND (node, 0) = modify;
14680         }
14681       else
14682         return error_mark_node;
14683     }
14684   TREE_TYPE (node) = void_type_node;
14685   TREE_SIDE_EFFECTS (node) = 1;
14686   return node;
14687 }
14688
14689 /* 14.8 The if Statement */
14690
14691 static tree
14692 build_if_else_statement (int location, tree expression, tree if_body,
14693                          tree else_body)
14694 {
14695   tree node;
14696   if (!else_body)
14697     else_body = build_java_empty_stmt ();
14698   node = build3 (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14699   EXPR_WFL_LINECOL (node) = location;
14700   node = build_debugable_stmt (location, node);
14701   return node;
14702 }
14703
14704 static tree
14705 patch_if_else_statement (tree node)
14706 {
14707   tree expression = TREE_OPERAND (node, 0);
14708   int can_complete_normally
14709     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14710        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14711
14712   TREE_TYPE (node) = error_mark_node;
14713   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14714
14715   /* The type of expression must be boolean */
14716   if (TREE_TYPE (expression) != boolean_type_node
14717       && TREE_TYPE (expression) != promoted_boolean_type_node)
14718     {
14719       parse_error_context
14720         (wfl_operator,
14721          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14722          lang_printable_name (TREE_TYPE (expression), 0));
14723       return error_mark_node;
14724     }
14725
14726   TREE_TYPE (node) = void_type_node;
14727   TREE_SIDE_EFFECTS (node) = 1;
14728   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14729   return node;
14730 }
14731
14732 /* 14.6 Labeled Statements */
14733
14734 /* Action taken when a labeled statement is parsed. a new
14735    LABELED_BLOCK_EXPR is created. No statement is attached to the
14736    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14737
14738 static tree
14739 build_labeled_block (int location, tree label)
14740 {
14741   tree label_name ;
14742   tree label_decl, node;
14743   if (label == NULL_TREE || label == continue_identifier_node)
14744     label_name = label;
14745   else
14746     {
14747       label_name = merge_qualified_name (label_id, label);
14748       /* Issue an error if we try to reuse a label that was previously
14749          declared */
14750       if (IDENTIFIER_LOCAL_VALUE (label_name))
14751         {
14752           EXPR_WFL_LINECOL (wfl_operator) = location;
14753           parse_error_context (wfl_operator,
14754             "Declaration of `%s' shadows a previous label declaration",
14755                                IDENTIFIER_POINTER (label));
14756           EXPR_WFL_LINECOL (wfl_operator) =
14757             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14758           parse_error_context (wfl_operator,
14759             "This is the location of the previous declaration of label `%s'",
14760                                IDENTIFIER_POINTER (label));
14761           java_error_count--;
14762         }
14763     }
14764
14765   label_decl = create_label_decl (label_name);
14766   node = build2 (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14767   EXPR_WFL_LINECOL (node) = location;
14768   TREE_SIDE_EFFECTS (node) = 1;
14769   return node;
14770 }
14771
14772 /* A labeled statement LBE is attached a statement.  */
14773
14774 static tree
14775 finish_labeled_statement (tree lbe, /* Labeled block expr */
14776                           tree statement)
14777 {
14778   /* In anyways, tie the loop to its statement */
14779   LABELED_BLOCK_BODY (lbe) = statement;
14780   pop_labeled_block ();
14781   POP_LABELED_BLOCK ();
14782   return lbe;
14783 }
14784
14785 /* 14.10, 14.11, 14.12 Loop Statements */
14786
14787 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14788    list. */
14789
14790 static tree
14791 build_new_loop (tree loop_body)
14792 {
14793   tree loop = build1 (LOOP_EXPR, NULL_TREE, loop_body);
14794   TREE_SIDE_EFFECTS (loop) = 1;
14795   PUSH_LOOP (loop);
14796   return loop;
14797 }
14798
14799 /* Create a loop body according to the following structure:
14800      COMPOUND_EXPR
14801        COMPOUND_EXPR            (loop main body)
14802          EXIT_EXPR              (this order is for while/for loops.
14803          LABELED_BLOCK_EXPR      the order is reversed for do loops)
14804            LABEL_DECL           (a continue occurring here branches at the
14805            BODY                  end of this labeled block)
14806        INCREMENT                (if any)
14807
14808   REVERSED, if nonzero, tells that the loop condition expr comes
14809   after the body, like in the do-while loop.
14810
14811   To obtain a loop, the loop body structure described above is
14812   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14813
14814    LABELED_BLOCK_EXPR
14815      LABEL_DECL                   (use this label to exit the loop)
14816      LOOP_EXPR
14817        <structure described above> */
14818
14819 static tree
14820 build_loop_body (int location, tree condition, int reversed)
14821 {
14822   tree first, second, body;
14823
14824   condition = build1 (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14825   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14826   condition = build_debugable_stmt (location, condition);
14827   TREE_SIDE_EFFECTS (condition) = 1;
14828
14829   body = build_labeled_block (0, continue_identifier_node);
14830   first = (reversed ? body : condition);
14831   second = (reversed ? condition : body);
14832   return build2 (COMPOUND_EXPR, NULL_TREE,
14833                  build2 (COMPOUND_EXPR, NULL_TREE, first, second),
14834                  build_java_empty_stmt ());
14835 }
14836
14837 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14838    their order) on the current loop. Unlink the current loop from the
14839    loop list.  */
14840
14841 static tree
14842 finish_loop_body (int location, tree condition, tree body, int reversed)
14843 {
14844   tree to_return = ctxp->current_loop;
14845   tree loop_body = LOOP_EXPR_BODY (to_return);
14846   if (condition)
14847     {
14848       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14849       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14850          The real EXIT_EXPR is one operand further. */
14851       EXPR_WFL_LINECOL (cnode) = location;
14852       /* This one is for accurate error reports */
14853       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14854       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14855     }
14856   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14857   POP_LOOP ();
14858   return to_return;
14859 }
14860
14861 /* Tailored version of finish_loop_body for FOR loops, when FOR
14862    loops feature the condition part */
14863
14864 static tree
14865 finish_for_loop (int location, tree condition, tree update, tree body)
14866 {
14867   /* Put the condition and the loop body in place */
14868   tree loop = finish_loop_body (location, condition, body, 0);
14869   /* LOOP is the current loop which has been now popped of the loop
14870      stack.  Mark the update block as reachable and install it.  We do
14871      this because the (current interpretation of the) JLS requires
14872      that the update expression be considered reachable even if the
14873      for loop's body doesn't complete normally.  */
14874   if (update != NULL_TREE && !IS_EMPTY_STMT (update))
14875     {
14876       tree up2 = update;
14877       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
14878         up2 = EXPR_WFL_NODE (up2);
14879       /* It is possible for the update expression to be an
14880          EXPR_WFL_NODE wrapping nothing.  */
14881       if (up2 != NULL_TREE && !IS_EMPTY_STMT (up2))
14882         {
14883           /* Try to detect constraint violations.  These would be
14884              programming errors somewhere.  */
14885           if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
14886               || TREE_CODE (up2) == LOOP_EXPR)
14887             abort ();
14888           SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
14889         }
14890     }
14891   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
14892   return loop;
14893 }
14894
14895 /* Try to find the loop a block might be related to. This comprises
14896    the case where the LOOP_EXPR is found as the second operand of a
14897    COMPOUND_EXPR, because the loop happens to have an initialization
14898    part, then expressed as the first operand of the COMPOUND_EXPR. If
14899    the search finds something, 1 is returned. Otherwise, 0 is
14900    returned. The search is assumed to start from a
14901    LABELED_BLOCK_EXPR's block.  */
14902
14903 static tree
14904 search_loop (tree statement)
14905 {
14906   if (TREE_CODE (statement) == LOOP_EXPR)
14907     return statement;
14908
14909   if (TREE_CODE (statement) == BLOCK)
14910     statement = BLOCK_SUBBLOCKS (statement);
14911   else
14912     return NULL_TREE;
14913
14914   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14915     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
14916       statement = TREE_OPERAND (statement, 1);
14917
14918   return (TREE_CODE (statement) == LOOP_EXPR
14919           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
14920 }
14921
14922 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
14923    returned otherwise.  */
14924
14925 static int
14926 labeled_block_contains_loop_p (tree block, tree loop)
14927 {
14928   if (!block)
14929     return 0;
14930
14931   if (LABELED_BLOCK_BODY (block) == loop)
14932     return 1;
14933
14934   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
14935     return 1;
14936
14937   return 0;
14938 }
14939
14940 /* If the loop isn't surrounded by a labeled statement, create one and
14941    insert LOOP as its body.  */
14942
14943 static tree
14944 patch_loop_statement (tree loop)
14945 {
14946   tree loop_label;
14947
14948   TREE_TYPE (loop) = void_type_node;
14949   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
14950     return loop;
14951
14952   loop_label = build_labeled_block (0, NULL_TREE);
14953   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
14954      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
14955   LABELED_BLOCK_BODY (loop_label) = loop;
14956   PUSH_LABELED_BLOCK (loop_label);
14957   return loop_label;
14958 }
14959
14960 /* 14.13, 14.14: break and continue Statements */
14961
14962 /* Build a break or a continue statement. a null NAME indicates an
14963    unlabeled break/continue statement.  */
14964
14965 static tree
14966 build_bc_statement (int location, int is_break, tree name)
14967 {
14968   tree break_continue, label_block_expr = NULL_TREE;
14969
14970   if (name)
14971     {
14972       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
14973             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
14974         /* Null means that we don't have a target for this named
14975            break/continue. In this case, we make the target to be the
14976            label name, so that the error can be reported accurately in
14977            patch_bc_statement. */
14978         label_block_expr = EXPR_WFL_NODE (name);
14979     }
14980   /* Unlabeled break/continue will be handled during the
14981      break/continue patch operation */
14982   break_continue = build2 (EXIT_BLOCK_EXPR, NULL_TREE,
14983                            label_block_expr, NULL_TREE);
14984
14985   IS_BREAK_STMT_P (break_continue) = is_break;
14986   TREE_SIDE_EFFECTS (break_continue) = 1;
14987   EXPR_WFL_LINECOL (break_continue) = location;
14988   break_continue = build_debugable_stmt (location, break_continue);
14989   return break_continue;
14990 }
14991
14992 /* Verification of a break/continue statement. */
14993
14994 static tree
14995 patch_bc_statement (tree node)
14996 {
14997   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
14998   tree labeled_block = ctxp->current_labeled_block;
14999   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15000
15001   /* Having an identifier here means that the target is unknown. */
15002   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15003     {
15004       parse_error_context (wfl_operator, "No label definition found for `%s'",
15005                            IDENTIFIER_POINTER (bc_label));
15006       return error_mark_node;
15007     }
15008   if (! IS_BREAK_STMT_P (node))
15009     {
15010       /* It's a continue statement. */
15011       for (;; labeled_block = TREE_CHAIN (labeled_block))
15012         {
15013           if (labeled_block == NULL_TREE)
15014             {
15015               if (bc_label == NULL_TREE)
15016                 parse_error_context (wfl_operator,
15017                                      "`continue' must be in loop");
15018               else
15019                 parse_error_context
15020                   (wfl_operator, "continue label `%s' does not name a loop",
15021                    IDENTIFIER_POINTER (bc_label));
15022               return error_mark_node;
15023             }
15024           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15025                == continue_identifier_node)
15026               && (bc_label == NULL_TREE
15027                   || TREE_CHAIN (labeled_block) == bc_label))
15028             {
15029               bc_label = labeled_block;
15030               break;
15031             }
15032         }
15033     }
15034   else if (!bc_label)
15035     {
15036       for (;; labeled_block = TREE_CHAIN (labeled_block))
15037         {
15038           if (labeled_block == NULL_TREE)
15039             {
15040               parse_error_context (wfl_operator,
15041                                      "`break' must be in loop or switch");
15042               return error_mark_node;
15043             }
15044           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15045           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15046               || search_loop (target_stmt))
15047             {
15048               bc_label = labeled_block;
15049               break;
15050             }
15051         }
15052     }
15053
15054   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15055   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15056
15057   /* Our break/continue don't return values. */
15058   TREE_TYPE (node) = void_type_node;
15059   /* Encapsulate the break within a compound statement so that it's
15060      expanded all the times by expand_expr (and not clobbered
15061      sometimes, like after a if statement) */
15062   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15063   TREE_SIDE_EFFECTS (node) = 1;
15064   return node;
15065 }
15066
15067 /* Process the exit expression belonging to a loop. Its type must be
15068    boolean.  */
15069
15070 static tree
15071 patch_exit_expr (tree node)
15072 {
15073   tree expression = TREE_OPERAND (node, 0);
15074   TREE_TYPE (node) = error_mark_node;
15075   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15076
15077   /* The type of expression must be boolean */
15078   if (TREE_TYPE (expression) != boolean_type_node)
15079     {
15080       parse_error_context
15081         (wfl_operator,
15082     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15083          lang_printable_name (TREE_TYPE (expression), 0));
15084       return error_mark_node;
15085     }
15086   /* Now we know things are allright, invert the condition, fold and
15087      return */
15088   TREE_OPERAND (node, 0) =
15089     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15090
15091   if (! integer_zerop (TREE_OPERAND (node, 0))
15092       && ctxp->current_loop != NULL_TREE
15093       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15094     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15095   if (! integer_onep (TREE_OPERAND (node, 0)))
15096     CAN_COMPLETE_NORMALLY (node) = 1;
15097
15098
15099   TREE_TYPE (node) = void_type_node;
15100   return node;
15101 }
15102
15103 /* 14.9 Switch statement */
15104
15105 static tree
15106 patch_switch_statement (tree node)
15107 {
15108   tree se = TREE_OPERAND (node, 0), se_type;
15109   tree save, iter;
15110
15111   /* Complete the switch expression */
15112   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15113   se_type = TREE_TYPE (se);
15114   /* The type of the switch expression must be char, byte, short or
15115      int */
15116   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15117     {
15118       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15119       parse_error_context (wfl_operator,
15120           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15121                            lang_printable_name (se_type, 0));
15122       /* This is what java_complete_tree will check */
15123       TREE_OPERAND (node, 0) = error_mark_node;
15124       return error_mark_node;
15125     }
15126
15127   /* Save and restore the outer case label list.  */
15128   save = case_label_list;
15129   case_label_list = NULL_TREE;
15130
15131   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15132
15133   /* See if we've found a duplicate label.  We can't leave this until
15134      code generation, because in `--syntax-only' and `-C' modes we
15135      don't do ordinary code generation.  */
15136   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15137     {
15138       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15139       tree subiter;
15140       for (subiter = TREE_CHAIN (iter);
15141            subiter != NULL_TREE;
15142            subiter = TREE_CHAIN (subiter))
15143         {
15144           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15145           if (val == subval)
15146             {
15147               EXPR_WFL_LINECOL (wfl_operator)
15148                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15149               /* The case_label_list is in reverse order, so print the
15150                  outer label first.  */
15151               parse_error_context (wfl_operator, "duplicate case label: `"
15152                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15153               EXPR_WFL_LINECOL (wfl_operator)
15154                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15155               parse_error_context (wfl_operator, "original label is here");
15156
15157               break;
15158             }
15159         }
15160     }
15161
15162   case_label_list = save;
15163
15164   /* Ready to return */
15165   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15166     {
15167       TREE_TYPE (node) = error_mark_node;
15168       return error_mark_node;
15169     }
15170   TREE_TYPE (node) = void_type_node;
15171   TREE_SIDE_EFFECTS (node) = 1;
15172   CAN_COMPLETE_NORMALLY (node)
15173     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15174       || ! SWITCH_HAS_DEFAULT (node);
15175   return node;
15176 }
15177
15178 /* Assertions.  */
15179
15180 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15181    might be NULL_TREE.  */
15182 static tree
15183 build_assertion (int location, tree condition, tree value)
15184 {
15185   tree node;
15186   tree klass = GET_CPC ();
15187
15188   if (! enable_assertions (klass))
15189     {
15190       condition = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15191                           boolean_false_node, condition);
15192       if (value == NULL_TREE)
15193         value = build_java_empty_stmt ();
15194       return build_if_else_statement (location, condition,
15195                                       value, NULL_TREE);
15196     }
15197
15198   if (! CLASS_USES_ASSERTIONS (klass))
15199     {
15200       tree field, classdollar, id, call;
15201       tree class_type = TREE_TYPE (klass);
15202
15203       field = add_field (class_type,
15204                          get_identifier ("$assertionsDisabled"),
15205                          boolean_type_node,
15206                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15207       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15208       FIELD_SYNTHETIC (field) = 1;
15209
15210       classdollar = build_incomplete_class_ref (location, class_type);
15211
15212       /* Call CLASS.desiredAssertionStatus().  */
15213       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15214       call = build3 (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15215       call = make_qualified_primary (classdollar, call, location);
15216       TREE_SIDE_EFFECTS (call) = 1;
15217
15218       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15219          seem odd, but we do it to generate code identical to that of
15220          the JDK.  */
15221       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15222       TREE_SIDE_EFFECTS (call) = 1;
15223       DECL_INITIAL (field) = call;
15224
15225       /* Record the initializer in the initializer statement list.  */
15226       call = build2 (MODIFY_EXPR, NULL_TREE, field, call);
15227       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15228       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15229       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15230
15231       CLASS_USES_ASSERTIONS (klass) = 1;
15232     }
15233
15234   if (value != NULL_TREE)
15235     value = tree_cons (NULL_TREE, value, NULL_TREE);
15236
15237   node = build_wfl_node (get_identifier ("java"));
15238   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15239                               location);
15240   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15241                               location);
15242
15243   node = build3 (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15244   TREE_SIDE_EFFECTS (node) = 1;
15245   /* It is too early to use BUILD_THROW.  */
15246   node = build1 (THROW_EXPR, NULL_TREE, node);
15247   TREE_SIDE_EFFECTS (node) = 1;
15248
15249   /* We invert the condition; if we just put NODE as the `else' part
15250      then we generate weird-looking bytecode.  */
15251   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15252   /* Check $assertionsDisabled.  */
15253   condition
15254     = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15255               build1 (TRUTH_NOT_EXPR, NULL_TREE,
15256                       build_wfl_node (get_identifier ("$assertionsDisabled"))),
15257               condition);
15258   node = build_if_else_statement (location, condition, node, NULL_TREE);
15259   return node;
15260 }
15261
15262 /* 14.18 The try/catch statements */
15263
15264 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15265    catches TYPE and executes CATCH_STMTS.  */
15266
15267 static tree
15268 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15269                             tree catch_stmts)
15270 {
15271   tree try_block, catch_clause_param, catch_block, catch;
15272
15273   /* First build a try block */
15274   try_block = build_expr_block (try_stmts, NULL_TREE);
15275
15276   /* Build a catch block: we need a catch clause parameter */
15277   if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15278     {
15279       tree catch_type = obtain_incomplete_type (type_or_name);
15280       jdep *dep;
15281       catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15282       register_incomplete_type (JDEP_VARIABLE, type_or_name,
15283                                 catch_clause_param, catch_type);
15284       dep = CLASSD_LAST (ctxp->classd_list);
15285       JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15286     }
15287   else
15288     catch_clause_param = build_decl (VAR_DECL, wpv_id,
15289                                      build_pointer_type (type_or_name));
15290
15291   /* And a block */
15292   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15293
15294   /* Initialize the variable and store in the block */
15295   catch = build2 (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15296                   build0 (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15297   add_stmt_to_block (catch_block, NULL_TREE, catch);
15298
15299   /* Add the catch statements */
15300   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15301
15302   /* Now we can build a JAVA_CATCH_EXPR */
15303   catch_block = build1 (JAVA_CATCH_EXPR, NULL_TREE, catch_block);
15304
15305   return build_try_statement (location, try_block, catch_block);
15306 }
15307
15308 static tree
15309 build_try_statement (int location, tree try_block, tree catches)
15310 {
15311   tree node = build2 (TRY_EXPR, NULL_TREE, try_block, catches);
15312   EXPR_WFL_LINECOL (node) = location;
15313   return node;
15314 }
15315
15316 static tree
15317 build_try_finally_statement (int location, tree try_block, tree finally)
15318 {
15319   tree node = build2 (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15320   EXPR_WFL_LINECOL (node) = location;
15321   return node;
15322 }
15323
15324 static tree
15325 patch_try_statement (tree node)
15326 {
15327   int error_found = 0;
15328   tree try = TREE_OPERAND (node, 0);
15329   /* Exception handlers are considered in left to right order */
15330   tree catch = nreverse (TREE_OPERAND (node, 1));
15331   tree current, caught_type_list = NULL_TREE;
15332
15333   /* Check catch clauses, if any. Every time we find an error, we try
15334      to process the next catch clause. We process the catch clause before
15335      the try block so that when processing the try block we can check thrown
15336      exceptions againts the caught type list. */
15337   for (current = catch; current; current = TREE_CHAIN (current))
15338     {
15339       tree carg_decl, carg_type;
15340       tree sub_current, catch_block, catch_clause;
15341       int unreachable;
15342
15343       /* At this point, the structure of the catch clause is
15344            JAVA_CATCH_EXPR              (catch node)
15345              BLOCK              (with the decl of the parameter)
15346                COMPOUND_EXPR
15347                  MODIFY_EXPR   (assignment of the catch parameter)
15348                  BLOCK          (catch clause block)
15349        */
15350       catch_clause = TREE_OPERAND (current, 0);
15351       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15352       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15353
15354       /* Catch clauses can't have more than one parameter declared,
15355          but it's already enforced by the grammar. Make sure that the
15356          only parameter of the clause statement in of class Throwable
15357          or a subclass of Throwable, but that was done earlier. The
15358          catch clause parameter type has also been resolved. */
15359
15360       /* Just make sure that the catch clause parameter type inherits
15361          from java.lang.Throwable */
15362       if (!inherits_from_p (carg_type, throwable_type_node))
15363         {
15364           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15365           parse_error_context (wfl_operator,
15366                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15367                                lang_printable_name (carg_type, 0));
15368           error_found = 1;
15369           continue;
15370         }
15371
15372       /* Partial check for unreachable catch statement: The catch
15373          clause is reachable iff is no earlier catch block A in
15374          the try statement such that the type of the catch
15375          clause's parameter is the same as or a subclass of the
15376          type of A's parameter */
15377       unreachable = 0;
15378       for (sub_current = catch;
15379            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15380         {
15381           tree sub_catch_clause, decl;
15382           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15383           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15384
15385           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15386             {
15387               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15388               parse_error_context
15389                 (wfl_operator,
15390                  "`catch' not reached because of the catch clause at line %d",
15391                  EXPR_WFL_LINENO (sub_current));
15392               unreachable = error_found = 1;
15393               break;
15394             }
15395         }
15396       /* Complete the catch clause block */
15397       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15398       if (catch_block == error_mark_node)
15399         {
15400           error_found = 1;
15401           continue;
15402         }
15403       if (CAN_COMPLETE_NORMALLY (catch_block))
15404         CAN_COMPLETE_NORMALLY (node) = 1;
15405       TREE_OPERAND (current, 0) = catch_block;
15406
15407       if (unreachable)
15408         continue;
15409
15410       /* Things to do here: the exception must be thrown */
15411
15412       /* Link this type to the caught type list */
15413       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15414     }
15415
15416   PUSH_EXCEPTIONS (caught_type_list);
15417   if ((try = java_complete_tree (try)) == error_mark_node)
15418     error_found = 1;
15419   if (CAN_COMPLETE_NORMALLY (try))
15420     CAN_COMPLETE_NORMALLY (node) = 1;
15421   POP_EXCEPTIONS ();
15422
15423   /* Verification ends here */
15424   if (error_found)
15425     return error_mark_node;
15426
15427   TREE_OPERAND (node, 0) = try;
15428   TREE_OPERAND (node, 1) = catch;
15429   TREE_TYPE (node) = void_type_node;
15430   return node;
15431 }
15432
15433 /* 14.17 The synchronized Statement */
15434
15435 static tree
15436 patch_synchronized_statement (tree node, tree wfl_op1)
15437 {
15438   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15439   tree block = TREE_OPERAND (node, 1);
15440
15441   tree tmp, enter, exit, expr_decl, assignment;
15442
15443   if (expr == error_mark_node)
15444     {
15445       block = java_complete_tree (block);
15446       return expr;
15447     }
15448
15449   /* We might be trying to synchronize on a STRING_CST */
15450   if ((tmp = patch_string (expr)))
15451     expr = tmp;
15452
15453   /* The TYPE of expr must be a reference type */
15454   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15455     {
15456       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15457       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15458                            lang_printable_name (TREE_TYPE (expr), 0));
15459       return error_mark_node;
15460     }
15461
15462   if (flag_emit_xref)
15463     {
15464       TREE_OPERAND (node, 0) = expr;
15465       TREE_OPERAND (node, 1) = java_complete_tree (block);
15466       CAN_COMPLETE_NORMALLY (node) = 1;
15467       return node;
15468     }
15469
15470   /* Generate a try-finally for the synchronized statement, except
15471      that the handler that catches all throw exception calls
15472      _Jv_MonitorExit and then rethrow the exception.
15473      The synchronized statement is then implemented as:
15474      TRY
15475        {
15476          _Jv_MonitorEnter (expression)
15477          synchronized_block
15478          _Jv_MonitorExit (expression)
15479        }
15480      CATCH_ALL
15481        {
15482          e = _Jv_exception_info ();
15483          _Jv_MonitorExit (expression)
15484          Throw (e);
15485        } */
15486
15487   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15488   BUILD_MONITOR_ENTER (enter, expr_decl);
15489   BUILD_MONITOR_EXIT (exit, expr_decl);
15490   CAN_COMPLETE_NORMALLY (enter) = 1;
15491   CAN_COMPLETE_NORMALLY (exit) = 1;
15492   assignment = build2 (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15493   TREE_SIDE_EFFECTS (assignment) = 1;
15494   node = build2 (COMPOUND_EXPR, NULL_TREE,
15495                  build2 (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15496                  build2 (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15497   node = build_expr_block (node, expr_decl);
15498
15499   return java_complete_tree (node);
15500 }
15501
15502 /* 14.16 The throw Statement */
15503
15504 static tree
15505 patch_throw_statement (tree node, tree wfl_op1)
15506 {
15507   tree expr = TREE_OPERAND (node, 0);
15508   tree type = TREE_TYPE (expr);
15509   int unchecked_ok = 0, tryblock_throws_ok = 0;
15510
15511   /* Thrown expression must be assignable to java.lang.Throwable */
15512   if (!try_reference_assignconv (throwable_type_node, expr))
15513     {
15514       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15515       parse_error_context (wfl_operator,
15516     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15517                            lang_printable_name (type, 0));
15518       /* If the thrown expression was a reference, we further the
15519          compile-time check. */
15520       if (!JREFERENCE_TYPE_P (type))
15521         return error_mark_node;
15522     }
15523
15524   /* At least one of the following must be true */
15525
15526   /* The type of the throw expression is a not checked exception,
15527      i.e. is a unchecked expression. */
15528   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15529
15530   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15531   /* An instance can't throw a checked exception unless that exception
15532      is explicitly declared in the `throws' clause of each
15533      constructor. This doesn't apply to anonymous classes, since they
15534      don't have declared constructors. */
15535   if (!unchecked_ok
15536       && DECL_INSTINIT_P (current_function_decl)
15537       && !ANONYMOUS_CLASS_P (current_class))
15538     {
15539       tree current;
15540       for (current = TYPE_METHODS (current_class); current;
15541            current = TREE_CHAIN (current))
15542         if (DECL_CONSTRUCTOR_P (current)
15543             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15544           {
15545             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)",
15546                                  lang_printable_name (TREE_TYPE (expr), 0));
15547             return error_mark_node;
15548           }
15549     }
15550
15551   /* Throw is contained in a try statement and at least one catch
15552      clause can receive the thrown expression or the current method is
15553      declared to throw such an exception. Or, the throw statement is
15554      contained in a method or constructor declaration and the type of
15555      the Expression is assignable to at least one type listed in the
15556      throws clause the declaration. */
15557   if (!unchecked_ok)
15558     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15559   if (!(unchecked_ok || tryblock_throws_ok))
15560     {
15561       /* If there is a surrounding try block that has no matching
15562          clatch clause, report it first. A surrounding try block exits
15563          only if there is something after the list of checked
15564          exception thrown by the current function (if any). */
15565       if (IN_TRY_BLOCK_P ())
15566         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15567                              lang_printable_name (type, 0));
15568       /* If we have no surrounding try statement and the method doesn't have
15569          any throws, report it now. FIXME */
15570
15571       /* We report that the exception can't be throw from a try block
15572          in all circumstances but when the `throw' is inside a static
15573          block. */
15574       else if (!EXCEPTIONS_P (currently_caught_type_list)
15575                && !tryblock_throws_ok)
15576         {
15577           if (DECL_CLINIT_P (current_function_decl))
15578             parse_error_context (wfl_operator,
15579                    "Checked exception `%s' can't be thrown in initializer",
15580                                  lang_printable_name (type, 0));
15581           else
15582             parse_error_context (wfl_operator,
15583                    "Checked exception `%s' isn't thrown from a `try' block",
15584                                  lang_printable_name (type, 0));
15585         }
15586       /* Otherwise, the current method doesn't have the appropriate
15587          throws declaration */
15588       else
15589         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15590                              lang_printable_name (type, 0));
15591       return error_mark_node;
15592     }
15593
15594   if (! flag_emit_class_files && ! flag_emit_xref)
15595     BUILD_THROW (node, expr);
15596
15597   /* If doing xrefs, keep the location where the `throw' was seen. */
15598   if (flag_emit_xref)
15599     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15600   return node;
15601 }
15602
15603 /* Check that exception said to be thrown by method DECL can be
15604    effectively caught from where DECL is invoked.  THIS_EXPR is the
15605    expression that computes `this' for the method call.  */
15606 static void
15607 check_thrown_exceptions (int location, tree decl, tree this_expr)
15608 {
15609   tree throws;
15610   int is_array_call = 0;
15611
15612   /* Skip check within generated methods, such as access$<n>.  */
15613   if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
15614     return;
15615
15616   if (this_expr != NULL_TREE
15617       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15618       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15619     is_array_call = 1;
15620
15621   /* For all the unchecked exceptions thrown by DECL.  */
15622   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15623        throws = TREE_CHAIN (throws))
15624     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15625       {
15626         /* Suppress errors about cloning arrays.  */
15627         if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15628           continue;
15629
15630         EXPR_WFL_LINECOL (wfl_operator) = location;
15631         if (DECL_FINIT_P (current_function_decl))
15632           parse_error_context
15633             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15634              lang_printable_name (TREE_VALUE (throws), 0));
15635         else
15636           {
15637             parse_error_context
15638               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15639                lang_printable_name (TREE_VALUE (throws), 0),
15640                (DECL_INIT_P (current_function_decl) ?
15641                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15642                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15643           }
15644       }
15645 }
15646
15647 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15648    try-catch blocks, OR is listed in the `throws' clause of the
15649    current method.  */
15650
15651 static int
15652 check_thrown_exceptions_do (tree exception)
15653 {
15654   tree list = currently_caught_type_list;
15655   resolve_and_layout (exception, NULL_TREE);
15656   /* First, all the nested try-catch-finally at that stage. The
15657      last element contains `throws' clause exceptions, if any. */
15658   if (IS_UNCHECKED_EXCEPTION_P (exception))
15659     return 1;
15660   while (list)
15661     {
15662       tree caught;
15663       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15664         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15665           return 1;
15666       list = TREE_CHAIN (list);
15667     }
15668   return 0;
15669 }
15670
15671 static void
15672 purge_unchecked_exceptions (tree mdecl)
15673 {
15674   tree throws = DECL_FUNCTION_THROWS (mdecl);
15675   tree new = NULL_TREE;
15676
15677   while (throws)
15678     {
15679       tree next = TREE_CHAIN (throws);
15680       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15681         {
15682           TREE_CHAIN (throws) = new;
15683           new = throws;
15684         }
15685       throws = next;
15686     }
15687   /* List is inverted here, but it doesn't matter */
15688   DECL_FUNCTION_THROWS (mdecl) = new;
15689 }
15690
15691 /* This function goes over all of CLASS_TYPE ctors and checks whether
15692    each of them features at least one unchecked exception in its
15693    `throws' clause. If it's the case, it returns `true', `false'
15694    otherwise.  */
15695
15696 static bool
15697 ctors_unchecked_throws_clause_p (tree class_type)
15698 {
15699   tree current;
15700
15701   for (current = TYPE_METHODS (class_type); current;
15702        current = TREE_CHAIN (current))
15703     {
15704       bool ctu = false; /* Ctor Throws Unchecked */
15705       if (DECL_CONSTRUCTOR_P (current))
15706         {
15707           tree throws;
15708           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15709                throws = TREE_CHAIN (throws))
15710             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15711               ctu = true;
15712         }
15713       /* We return false as we found one ctor that is unfit. */
15714       if (!ctu && DECL_CONSTRUCTOR_P (current))
15715         return false;
15716     }
15717   /* All ctors feature at least one unchecked exception in their
15718      `throws' clause. */
15719   return true;
15720 }
15721
15722 /* 15.24 Conditional Operator ?: */
15723
15724 static tree
15725 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15726 {
15727   tree cond = TREE_OPERAND (node, 0);
15728   tree op1 = TREE_OPERAND (node, 1);
15729   tree op2 = TREE_OPERAND (node, 2);
15730   tree resulting_type = NULL_TREE;
15731   tree t1, t2, patched;
15732   int error_found = 0;
15733
15734   /* Operands of ?: might be StringBuffers crafted as a result of a
15735      string concatenation. Obtain a descent operand here.  */
15736   if ((patched = patch_string (op1)))
15737     TREE_OPERAND (node, 1) = op1 = patched;
15738   if ((patched = patch_string (op2)))
15739     TREE_OPERAND (node, 2) = op2 = patched;
15740
15741   t1 = TREE_TYPE (op1);
15742   t2 = TREE_TYPE (op2);
15743
15744   /* The first expression must be a boolean */
15745   if (TREE_TYPE (cond) != boolean_type_node)
15746     {
15747       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15748       parse_error_context (wfl_operator,
15749                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15750                            lang_printable_name (TREE_TYPE (cond), 0));
15751       error_found = 1;
15752     }
15753
15754   /* Second and third can be numeric, boolean (i.e. primitive),
15755      references or null. Anything else results in an error */
15756   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15757         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15758             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15759         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15760     error_found = 1;
15761
15762   /* Determine the type of the conditional expression. Same types are
15763      easy to deal with */
15764   else if (t1 == t2)
15765     resulting_type = t1;
15766
15767   /* There are different rules for numeric types */
15768   else if (JNUMERIC_TYPE_P (t1))
15769     {
15770       /* if byte/short found, the resulting type is short */
15771       if ((t1 == byte_type_node && t2 == short_type_node)
15772           || (t1 == short_type_node && t2 == byte_type_node))
15773         resulting_type = short_type_node;
15774
15775       /* If t1 is a constant int and t2 is of type byte, short or char
15776          and t1's value fits in t2, then the resulting type is t2 */
15777       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15778           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15779         resulting_type = t2;
15780
15781       /* If t2 is a constant int and t1 is of type byte, short or char
15782          and t2's value fits in t1, then the resulting type is t1 */
15783       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15784           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15785         resulting_type = t1;
15786
15787       /* Otherwise, binary numeric promotion is applied and the
15788          resulting type is the promoted type of operand 1 and 2 */
15789       else
15790         resulting_type = binary_numeric_promotion (t1, t2,
15791                                                    &TREE_OPERAND (node, 1),
15792                                                    &TREE_OPERAND (node, 2));
15793     }
15794
15795   /* Cases of a reference and a null type */
15796   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15797     resulting_type = t1;
15798
15799   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15800     resulting_type = t2;
15801
15802   /* Last case: different reference types. If a type can be converted
15803      into the other one by assignment conversion, the latter
15804      determines the type of the expression */
15805   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15806     resulting_type = promote_type (t1);
15807
15808   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15809     resulting_type = promote_type (t2);
15810
15811   /* If we don't have any resulting type, we're in trouble */
15812   if (!resulting_type)
15813     {
15814       char *t = xstrdup (lang_printable_name (t1, 0));
15815       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15816       parse_error_context (wfl_operator,
15817                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15818                            t, lang_printable_name (t2, 0));
15819       free (t);
15820       error_found = 1;
15821     }
15822
15823   if (error_found)
15824     {
15825       TREE_TYPE (node) = error_mark_node;
15826       return error_mark_node;
15827     }
15828
15829   TREE_TYPE (node) = resulting_type;
15830   TREE_SET_CODE (node, COND_EXPR);
15831   CAN_COMPLETE_NORMALLY (node) = 1;
15832   return node;
15833 }
15834
15835 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15836
15837 static tree
15838 maybe_build_class_init_for_field (tree decl, tree expr)
15839 {
15840   tree clas = DECL_CONTEXT (decl);
15841   if (flag_emit_class_files || flag_emit_xref)
15842     return expr;
15843
15844   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
15845       && FIELD_FINAL (decl))
15846     {
15847       tree init = DECL_INITIAL (decl);
15848       if (init != NULL_TREE)
15849         init = fold_constant_for_init (init, decl);
15850       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
15851         return expr;
15852     }
15853
15854   return build_class_init (clas, expr);
15855 }
15856
15857 /* Try to constant fold NODE.
15858    If NODE is not a constant expression, return NULL_EXPR.
15859    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15860
15861 static tree
15862 fold_constant_for_init (tree node, tree context)
15863 {
15864   tree op0, op1, val;
15865   enum tree_code code = TREE_CODE (node);
15866
15867   switch (code)
15868     {
15869     case INTEGER_CST:
15870       if (node == null_pointer_node)
15871         return NULL_TREE;
15872     case STRING_CST:
15873     case REAL_CST:
15874       return node;
15875
15876     case PLUS_EXPR:
15877     case MINUS_EXPR:
15878     case MULT_EXPR:
15879     case TRUNC_MOD_EXPR:
15880     case RDIV_EXPR:
15881     case LSHIFT_EXPR:
15882     case RSHIFT_EXPR:
15883     case URSHIFT_EXPR:
15884     case BIT_AND_EXPR:
15885     case BIT_XOR_EXPR:
15886     case BIT_IOR_EXPR:
15887     case TRUTH_ANDIF_EXPR:
15888     case TRUTH_ORIF_EXPR:
15889     case EQ_EXPR:
15890     case NE_EXPR:
15891     case GT_EXPR:
15892     case GE_EXPR:
15893     case LT_EXPR:
15894     case LE_EXPR:
15895       op0 = TREE_OPERAND (node, 0);
15896       op1 = TREE_OPERAND (node, 1);
15897       val = fold_constant_for_init (op0, context);
15898       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15899         return NULL_TREE;
15900       TREE_OPERAND (node, 0) = val;
15901       val = fold_constant_for_init (op1, context);
15902       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15903         return NULL_TREE;
15904       TREE_OPERAND (node, 1) = val;
15905       return patch_binop (node, op0, op1);
15906
15907     case UNARY_PLUS_EXPR:
15908     case NEGATE_EXPR:
15909     case TRUTH_NOT_EXPR:
15910     case BIT_NOT_EXPR:
15911     case CONVERT_EXPR:
15912       op0 = TREE_OPERAND (node, 0);
15913       val = fold_constant_for_init (op0, context);
15914       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15915         return NULL_TREE;
15916       TREE_OPERAND (node, 0) = val;
15917       val = patch_unaryop (node, op0);
15918       if (! TREE_CONSTANT (val))
15919         return NULL_TREE;
15920       return val;
15921
15922       break;
15923
15924     case COND_EXPR:
15925       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
15926       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15927         return NULL_TREE;
15928       TREE_OPERAND (node, 0) = val;
15929       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
15930       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15931         return NULL_TREE;
15932       TREE_OPERAND (node, 1) = val;
15933       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
15934       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15935         return NULL_TREE;
15936       TREE_OPERAND (node, 2) = val;
15937       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
15938         : TREE_OPERAND (node, 2);
15939
15940     case VAR_DECL:
15941     case FIELD_DECL:
15942       if (! FIELD_FINAL (node)
15943           || DECL_INITIAL (node) == NULL_TREE)
15944         return NULL_TREE;
15945       val = DECL_INITIAL (node);
15946       /* Guard against infinite recursion. */
15947       DECL_INITIAL (node) = NULL_TREE;
15948       val = fold_constant_for_init (val, node);
15949       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
15950         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
15951       DECL_INITIAL (node) = val;
15952       return val;
15953
15954     case EXPR_WITH_FILE_LOCATION:
15955       /* Compare java_complete_tree and resolve_expression_name. */
15956       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
15957           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
15958         {
15959           tree name = EXPR_WFL_NODE (node);
15960           tree decl;
15961           if (PRIMARY_P (node))
15962             return NULL_TREE;
15963           else if (! QUALIFIED_P (name))
15964             {
15965               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
15966               if (decl == NULL_TREE
15967                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
15968                 return NULL_TREE;
15969               return fold_constant_for_init (decl, decl);
15970             }
15971           else
15972             {
15973               tree r = NULL_TREE;
15974               /* Install the proper context for the field resolution.  */
15975               tree saved_current_class = current_class;
15976               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
15977               current_class = DECL_CONTEXT (context);
15978               qualify_ambiguous_name (node);
15979               r = resolve_field_access (node, &decl, NULL);
15980               /* Restore prior context.  */
15981               current_class = saved_current_class;
15982               if (r != error_mark_node && decl != NULL_TREE)
15983                 return fold_constant_for_init (decl, decl);
15984               return NULL_TREE;
15985             }
15986         }
15987       else
15988         {
15989           op0 = TREE_OPERAND (node, 0);
15990           val = fold_constant_for_init (op0, context);
15991           if (val == NULL_TREE || ! TREE_CONSTANT (val))
15992             return NULL_TREE;
15993           TREE_OPERAND (node, 0) = val;
15994           return val;
15995         }
15996
15997 #ifdef USE_COMPONENT_REF
15998     case IDENTIFIER:
15999     case COMPONENT_REF:
16000       ?;
16001 #endif
16002
16003     default:
16004       return NULL_TREE;
16005     }
16006 }
16007
16008 #ifdef USE_COMPONENT_REF
16009 /* Context is 'T' for TypeName, 'P' for PackageName,
16010    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16011
16012 tree
16013 resolve_simple_name (tree name, int context)
16014 {
16015 }
16016
16017 tree
16018 resolve_qualified_name (tree name, int context)
16019 {
16020 }
16021 #endif
16022
16023 void
16024 init_src_parse (void)
16025 {
16026   /* Sanity check; we've been bit by this before.  */
16027   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16028     abort ();
16029 }
16030
16031 \f
16032
16033 /* This section deals with the functions that are called when tables
16034    recording class initialization information are traversed.  */
16035
16036 /* Attach to PTR (a block) the declaration found in ENTRY. */
16037
16038 static int
16039 attach_init_test_initialization_flags (void **entry, void *ptr)
16040 {
16041   tree block = (tree)ptr;
16042   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16043
16044   if (block != error_mark_node)
16045     {
16046       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16047       BLOCK_EXPR_DECLS (block) = ite->value;
16048     }
16049   return true;
16050 }
16051
16052 /* This function is called for each class that is known definitely
16053    initialized when a given static method was called. This function
16054    augments a compound expression (INFO) storing all assignment to
16055    initialized static class flags if a flag already existed, otherwise
16056    a new one is created.  */
16057
16058 static int
16059 emit_test_initialization (void **entry_p, void *info)
16060 {
16061   tree l = (tree) info;
16062   tree decl, init;
16063   tree key = (tree) *entry_p;
16064   tree *ite;
16065   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16066
16067   /* If we haven't found a flag and we're dealing with self registered
16068      with current_function_decl, then don't do anything. Self is
16069      always added as definitely initialized but this information is
16070      valid only if used outside the current function. */
16071   if (current_function_decl == TREE_PURPOSE (l)
16072       && java_treetreehash_find (cf_ht, key) == NULL)
16073     return true;
16074
16075   ite = java_treetreehash_new (cf_ht, key);
16076
16077   /* If we don't have a variable, create one and install it. */
16078   if (*ite == NULL)
16079     {
16080       tree block;
16081
16082       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16083       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16084       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16085       DECL_CONTEXT (decl) = current_function_decl;
16086       DECL_INITIAL (decl) = boolean_true_node;
16087       /* Don't emit any symbolic debugging info for this decl.  */
16088       DECL_IGNORED_P (decl) = 1;
16089
16090       /* The trick is to find the right context for it. */
16091       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16092       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16093       BLOCK_EXPR_DECLS (block) = decl;
16094       *ite = decl;
16095     }
16096   else
16097     decl = *ite;
16098
16099   /* Now simply augment the compound that holds all the assignments
16100      pertaining to this method invocation. */
16101   init = build2 (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16102   TREE_SIDE_EFFECTS (init) = 1;
16103   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16104   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16105
16106   return true;
16107 }
16108
16109 #include "gt-java-parse.h"
16110 #include "gtype-java.h"