gcc/java/parse.y

   1 /* Source code parsing and tree node generation for the GNU compiler
   2    for the Java(TM) language.
   3    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
   4    Free Software Foundation, Inc.
   5    Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.
  23
  24 Java and all Java-based marks are trademarks or registered trademarks
  25 of Sun Microsystems, Inc. in the United States and other countries.
  26 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  27
  28 /* This file parses java source code and issues a tree node image
  29 suitable for code generation (byte code and targeted CPU assembly
  30 language).
  31
  32 The grammar conforms to the Java grammar described in "The Java(TM)
  33 Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
  34 1996, ISBN 0-201-63451-1"
  35
  36 The following modifications were brought to the original grammar:
  37
  38 method_body: added the rule '| block SC_TK'
  39 static_initializer: added the rule 'static block SC_TK'.
  40
  41 Note: All the extra rules described above should go away when the
  42       empty_statement rule will work.
  43
  44 statement_nsi: 'nsi' should be read no_short_if.
  45
  46 Some rules have been modified to support JDK1.1 inner classes
  47 definitions and other extensions.  */
  48
  49 %{
  50 #include "config.h"
  51 #include "system.h"
  52 #include "coretypes.h"
  53 #include "tm.h"
  54 #include <dirent.h>
  55 #include "tree.h"
  56 #include "rtl.h"
  57 #include "real.h"
  58 #include "obstack.h"
  59 #include "toplev.h"
  60 #include "flags.h"
  61 #include "java-tree.h"
  62 #include "jcf.h"
  63 #include "lex.h"
  64 #include "parse.h"
  65 #include "zipfile.h"
  66 #include "convert.h"
  67 #include "buffer.h"
  68 #include "xref.h"
  69 #include "function.h"
  70 #include "except.h"
  71 #include "ggc.h"
  72 #include "debug.h"
  73 #include "tree-inline.h"
  74 #include "cgraph.h"
  75 #include "target.h"
  76
  77 /* Local function prototypes */
  78 static char *java_accstring_lookup (int);
  79 static const char *accessibility_string (int);
  80 static void  classitf_redefinition_error (const char *,tree, tree, tree);
  81 static void  variable_redefinition_error (tree, tree, tree, int);
  82 static tree  create_class (int, tree, tree, tree);
  83 static tree  create_interface (int, tree, tree);
  84 static void  end_class_declaration (int);
  85 static tree  find_field (tree, tree);
  86 static tree lookup_field_wrapper (tree, tree);
  87 static int   duplicate_declaration_error_p (tree, tree, tree);
  88 static void  register_fields (int, tree, tree);
  89 static tree parser_qualified_classname (tree);
  90 static int  parser_check_super (tree, tree, tree);
  91 static int  parser_check_super_interface (tree, tree, tree);
  92 static void check_modifiers_consistency (int);
  93 static tree lookup_cl (tree);
  94 static tree lookup_java_method2 (tree, tree, int);
  95 static tree method_header (int, tree, tree, tree);
  96 static void fix_method_argument_names (tree ,tree);
  97 static tree method_declarator (tree, tree);
  98 static void parse_warning_context (tree cl, const char *msg, ...)
  99   ATTRIBUTE_PRINTF_2;
 100 static void issue_warning_error_from_context (tree, const char *msg, va_list)
 101   ATTRIBUTE_PRINTF (2, 0);
 102 static void parse_ctor_invocation_error (void);
 103 static tree parse_jdk1_1_error (const char *);
 104 static void complete_class_report_errors (jdep *);
 105 static int process_imports (void);
 106 static void read_import_dir (tree);
 107 static int find_in_imports_on_demand (tree, tree);
 108 static void find_in_imports (tree, tree);
 109 static void check_inner_class_access (tree, tree, tree);
 110 static int check_pkg_class_access (tree, tree, bool, tree);
 111 static void register_package (tree);
 112 static tree resolve_package (tree, tree *, tree *);
 113 static tree resolve_class (tree, tree, tree, tree);
 114 static void declare_local_variables (int, tree, tree);
 115 static void dump_java_tree (enum tree_dump_index, tree);
 116 static void source_start_java_method (tree);
 117 static void source_end_java_method (void);
 118 static tree find_name_in_single_imports (tree);
 119 static void check_abstract_method_header (tree);
 120 static tree lookup_java_interface_method2 (tree, tree);
 121 static tree resolve_expression_name (tree, tree *);
 122 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
 123 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
 124 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
 125 static int breakdown_qualified (tree *, tree *, tree);
 126 static int in_same_package (tree, tree);
 127 static tree resolve_and_layout (tree, tree);
 128 static tree qualify_and_find (tree, tree, tree);
 129 static tree resolve_no_layout (tree, tree);
 130 static int invocation_mode (tree, int);
 131 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
 132 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
 133 static tree find_most_specific_methods_list (tree);
 134 static int argument_types_convertible (tree, tree);
 135 static tree patch_invoke (tree, tree, tree);
 136 static int maybe_use_access_method (int, tree *, tree *);
 137 static tree lookup_method_invoke (int, tree, tree, tree, tree);
 138 static tree register_incomplete_type (int, tree, tree, tree);
 139 static tree check_inner_circular_reference (tree, tree);
 140 static tree check_circular_reference (tree);
 141 static tree obtain_incomplete_type (tree);
 142 static tree java_complete_lhs (tree);
 143 static tree java_complete_tree (tree);
 144 static tree maybe_generate_pre_expand_clinit (tree);
 145 static int analyze_clinit_body (tree, tree);
 146 static int maybe_yank_clinit (tree);
 147 static void java_complete_expand_method (tree);
 148 static void java_expand_method_bodies (tree);
 149 static int  unresolved_type_p (tree, tree *);
 150 static void create_jdep_list (struct parser_ctxt *);
 151 static tree build_expr_block (tree, tree);
 152 static tree enter_block (void);
 153 static tree exit_block (void);
 154 static tree lookup_name_in_blocks (tree);
 155 static void maybe_absorb_scoping_blocks (void);
 156 static tree build_method_invocation (tree, tree);
 157 static tree build_new_invocation (tree, tree);
 158 static tree build_assignment (int, int, tree, tree);
 159 static tree build_binop (enum tree_code, int, tree, tree);
 160 static tree patch_assignment (tree, tree);
 161 static tree patch_binop (tree, tree, tree);
 162 static tree build_unaryop (int, int, tree);
 163 static tree build_incdec (int, int, tree, int);
 164 static tree patch_unaryop (tree, tree);
 165 static tree build_cast (int, tree, tree);
 166 static tree build_null_of_type (tree);
 167 static tree patch_cast (tree, tree);
 168 static int valid_ref_assignconv_cast_p (tree, tree, int);
 169 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
 170 static int valid_cast_to_p (tree, tree);
 171 static int valid_method_invocation_conversion_p (tree, tree);
 172 static tree try_builtin_assignconv (tree, tree, tree);
 173 static tree try_reference_assignconv (tree, tree);
 174 static tree build_unresolved_array_type (tree);
 175 static int build_type_name_from_array_name (tree, tree *);
 176 static tree build_array_from_name (tree, tree, tree, tree *);
 177 static tree build_array_ref (int, tree, tree);
 178 static tree patch_array_ref (tree);
 179 static tree make_qualified_name (tree, tree, int);
 180 static tree merge_qualified_name (tree, tree);
 181 static tree make_qualified_primary (tree, tree, int);
 182 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
 183 static void qualify_ambiguous_name (tree);
 184 static tree resolve_field_access (tree, tree *, tree *);
 185 static tree build_newarray_node (tree, tree, int);
 186 static tree patch_newarray (tree);
 187 static tree resolve_type_during_patch (tree);
 188 static tree build_this (int);
 189 static tree build_wfl_wrap (tree, int);
 190 static tree build_return (int, tree);
 191 static tree patch_return (tree);
 192 static tree maybe_access_field (tree, tree, tree);
 193 static int complete_function_arguments (tree);
 194 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
 195 static int not_accessible_p (tree, tree, tree, int);
 196 static void check_deprecation (tree, tree);
 197 static int class_in_current_package (tree);
 198 static tree build_if_else_statement (int, tree, tree, tree);
 199 static tree patch_if_else_statement (tree);
 200 static tree add_stmt_to_compound (tree, tree, tree);
 201 static tree add_stmt_to_block (tree, tree, tree);
 202 static tree patch_exit_expr (tree);
 203 static tree build_labeled_block (int, tree);
 204 static tree finish_labeled_statement (tree, tree);
 205 static tree build_bc_statement (int, int, tree);
 206 static tree patch_bc_statement (tree);
 207 static tree patch_loop_statement (tree);
 208 static tree build_new_loop (tree);
 209 static tree build_loop_body (int, tree, int);
 210 static tree finish_loop_body (int, tree, tree, int);
 211 static tree build_debugable_stmt (int, tree);
 212 static tree finish_for_loop (int, tree, tree, tree);
 213 static tree patch_switch_statement (tree);
 214 static tree string_constant_concatenation (tree, tree);
 215 static tree build_string_concatenation (tree, tree);
 216 static tree patch_string_cst (tree);
 217 static tree patch_string (tree);
 218 static tree encapsulate_with_try_catch (int, tree, tree, tree);
 219 static tree build_assertion (int, tree, tree);
 220 static tree build_try_statement (int, tree, tree);
 221 static tree build_try_finally_statement (int, tree, tree);
 222 static tree patch_try_statement (tree);
 223 static tree patch_synchronized_statement (tree, tree);
 224 static tree patch_throw_statement (tree, tree);
 225 static void check_thrown_exceptions (int, tree, tree);
 226 static int check_thrown_exceptions_do (tree);
 227 static void purge_unchecked_exceptions (tree);
 228 static bool ctors_unchecked_throws_clause_p (tree);
 229 static void check_concrete_throws_clauses (tree, tree, tree, tree);
 230 static void check_throws_clauses (tree, tree, tree);
 231 static void finish_method_declaration (tree);
 232 static tree build_super_invocation (tree);
 233 static int verify_constructor_circularity (tree, tree);
 234 static char *constructor_circularity_msg (tree, tree);
 235 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
 236 static const char *get_printable_method_name (tree);
 237 static tree patch_conditional_expr (tree, tree, tree);
 238 static tree generate_finit (tree);
 239 static tree generate_instinit (tree);
 240 static tree build_instinit_invocation (tree);
 241 static void fix_constructors (tree);
 242 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
 243 static tree craft_constructor (tree, tree);
 244 static int verify_constructor_super (tree);
 245 static tree create_artificial_method (tree, int, tree, tree, tree);
 246 static void start_artificial_method_body (tree);
 247 static void end_artificial_method_body (tree);
 248 static int check_method_redefinition (tree, tree);
 249 static int check_method_types_complete (tree);
 250 static bool hack_is_accessible_p (tree, tree);
 251 static void java_check_regular_methods (tree);
 252 static void check_interface_throws_clauses (tree, tree);
 253 static void java_check_abstract_methods (tree);
 254 static void unreachable_stmt_error (tree);
 255 static int not_accessible_field_error (tree, tree);
 256 static tree find_expr_with_wfl (tree);
 257 static void missing_return_error (tree);
 258 static tree build_new_array_init (int, tree);
 259 static tree patch_new_array_init (tree, tree);
 260 static tree maybe_build_array_element_wfl (tree);
 261 static int array_constructor_check_entry (tree, tree);
 262 static const char *purify_type_name (const char *);
 263 static tree fold_constant_for_init (tree, tree);
 264 static tree strip_out_static_field_access_decl (tree);
 265 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
 266 static void static_ref_err (tree, tree, tree);
 267 static void parser_add_interface (tree, tree, tree);
 268 static void add_superinterfaces (tree, tree);
 269 static tree jdep_resolve_class (jdep *);
 270 static int note_possible_classname (const char *, int);
 271 static void java_complete_expand_classes (void);
 272 static void java_complete_expand_class (tree);
 273 static void java_complete_expand_methods (tree);
 274 static tree cut_identifier_in_qualified (tree);
 275 static tree java_stabilize_reference (tree);
 276 static tree do_unary_numeric_promotion (tree);
 277 static char * operator_string (tree);
 278 static tree do_merge_string_cste (tree, const char *, int, int);
 279 static tree merge_string_cste (tree, tree, int);
 280 static tree java_refold (tree);
 281 static int java_decl_equiv (tree, tree);
 282 static int binop_compound_p (enum tree_code);
 283 static tree search_loop (tree);
 284 static int labeled_block_contains_loop_p (tree, tree);
 285 static int check_abstract_method_definitions (int, tree, tree);
 286 static void java_check_abstract_method_definitions (tree);
 287 static void java_debug_context_do (int);
 288 static void java_parser_context_push_initialized_field (void);
 289 static void java_parser_context_pop_initialized_field (void);
 290 static tree reorder_static_initialized (tree);
 291 static void java_parser_context_suspend (void);
 292 static void java_parser_context_resume (void);
 293 static int pop_current_osb (struct parser_ctxt *);
 294
 295 /* JDK 1.1 work. FIXME */
 296
 297 static tree maybe_make_nested_class_name (tree);
 298 static int make_nested_class_name (tree);
 299 static void set_nested_class_simple_name_value (tree, int);
 300 static void link_nested_class_to_enclosing (void);
 301 static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
 302 static tree find_as_inner_class (tree, tree, tree);
 303 static tree find_as_inner_class_do (tree, tree);
 304 static int check_inner_class_redefinition (tree, tree);
 305
 306 static tree build_thisn_assign (void);
 307 static tree build_current_thisn (tree);
 308 static tree build_access_to_thisn (tree, tree, int);
 309 static tree maybe_build_thisn_access_method (tree);
 310
 311 static tree build_outer_field_access (tree, tree);
 312 static tree build_outer_field_access_methods (tree);
 313 static tree build_outer_field_access_expr (int, tree, tree,
 314                                                   tree, tree);
 315 static tree build_outer_method_access_method (tree);
 316 static tree build_new_access_id (void);
 317 static tree build_outer_field_access_method (tree, tree, tree,
 318                                                     tree, tree);
 319
 320 static int outer_field_access_p (tree, tree);
 321 static int outer_field_expanded_access_p (tree, tree *,
 322                                                  tree *, tree *);
 323 static tree outer_field_access_fix (tree, tree, tree);
 324 static tree build_incomplete_class_ref (int, tree);
 325 static tree patch_incomplete_class_ref (tree);
 326 static tree create_anonymous_class (int, tree);
 327 static void patch_anonymous_class (tree, tree, tree);
 328 static void add_inner_class_fields (tree, tree);
 329
 330 static tree build_dot_class_method (tree);
 331 static tree build_dot_class_method_invocation (tree, tree);
 332 static void create_new_parser_context (int);
 333 static tree maybe_build_class_init_for_field (tree, tree);
 334
 335 static int attach_init_test_initialization_flags (void **, void *);
 336 static int emit_test_initialization (void **, void *);
 337
 338 static char *string_convert_int_cst (tree);
 339
 340 /* Number of error found so far. */
 341 int java_error_count;
 342 /* Number of warning found so far. */
 343 int java_warning_count;
 344 /* Tell when not to fold, when doing xrefs */
 345 int do_not_fold;
 346 /* Cyclic inheritance report, as it can be set by layout_class */
 347 const char *cyclic_inheritance_report;
 348
 349 /* The current parser context */
 350 struct parser_ctxt *ctxp;
 351
 352 /* List of things that were analyzed for which code will be generated */
 353 struct parser_ctxt *ctxp_for_generation = NULL;
 354
 355 /* binop_lookup maps token to tree_code. It is used where binary
 356    operations are involved and required by the parser. RDIV_EXPR
 357    covers both integral/floating point division. The code is changed
 358    once the type of both operator is worked out.  */
 359
 360 static const enum tree_code binop_lookup[19] =
 361   {
 362     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
 363     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
 364     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
 365     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
 366     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
 367    };
 368 #define BINOP_LOOKUP(VALUE)                                             \
 369   binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
 370
 371 /* This is the end index for binary operators that can also be used
 372    in compound assignments. */
 373 #define BINOP_COMPOUND_CANDIDATES 11
 374
 375 /* The "$L" identifier we use to create labels.  */
 376 static GTY(()) tree label_id;
 377
 378 /* The "StringBuffer" identifier used for the String `+' operator. */
 379 static GTY(()) tree wfl_string_buffer;
 380
 381 /* The "append" identifier used for String `+' operator.  */
 382 static GTY(()) tree wfl_append;
 383
 384 /* The "toString" identifier used for String `+' operator. */
 385 static GTY(()) tree wfl_to_string;
 386
 387 /* The "java.lang" import qualified name.  */
 388 static GTY(()) tree java_lang_id;
 389
 390 /* The generated `inst$' identifier used for generated enclosing
 391    instance/field access functions.  */
 392 static GTY(()) tree inst_id;
 393
 394 /* Context and flag for static blocks */
 395 static GTY(()) tree current_static_block;
 396
 397 /* The generated `write_parm_value$' identifier.  */
 398 static GTY(()) tree wpv_id;
 399
 400 /* The list of all packages we've seen so far */
 401 static GTY(()) tree package_list;
 402
 403 /* Hold THIS for the scope of the current method decl.  */
 404 static GTY(()) tree current_this;
 405
 406 /* Hold a list of catch clauses list. The first element of this list is
 407    the list of the catch clauses of the currently analyzed try block. */
 408 static GTY(()) tree currently_caught_type_list;
 409
 410 /* This holds a linked list of all the case labels for the current
 411    switch statement.  It is only used when checking to see if there
 412    are duplicate labels.  FIXME: probably this should just be attached
 413    to the switch itself; then it could be referenced via
 414    `ctxp->current_loop'.  */
 415 static GTY(()) tree case_label_list;
 416
 417 /* Anonymous class counter. Will be reset to 1 every time a non
 418    anonymous class gets created. */
 419 static int anonymous_class_counter = 1;
 420
 421 static GTY(()) tree src_parse_roots[1];
 422
 423 /* All classes seen from source code */
 424 #define gclass_list src_parse_roots[0]
 425
 426 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
 427    line and point it out.  */
 428 /* Should point out the one that don't fit. ASCII/unicode, going
 429    backward. FIXME */
 430
 431 #define check_modifiers(__message, __value, __mask) do {        \
 432   if ((__value) & ~(__mask))                                    \
 433     {                                                           \
 434       size_t i, remainder = (__value) & ~(__mask);              \
 435       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)     \
 436         if ((1 << i) & remainder)                               \
 437           parse_error_context (ctxp->modifier_ctx [i], (__message), \
 438                                java_accstring_lookup (1 << i)); \
 439     }                                                           \
 440 } while (0)
 441
 442 %}
 443
 444 %union {
 445   tree node;
 446   int sub_token;
 447   struct {
 448     int token;
 449     int location;
 450   } operator;
 451   int value;
 452 }
 453
 454 %{
 455 #include "lex.c"
 456 %}
 457
 458 %pure_parser
 459
 460 /* Things defined here have to match the order of what's in the
 461    binop_lookup table.  */
 462
 463 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
 464 %token   LS_TK           SRS_TK          ZRS_TK
 465 %token   AND_TK          XOR_TK          OR_TK
 466 %token   BOOL_AND_TK BOOL_OR_TK
 467 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
 468
 469 /* This maps to the same binop_lookup entry than the token above */
 470
 471 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
 472 %token   REM_ASSIGN_TK
 473 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 474 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
 475
 476
 477 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
 478
 479 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
 480 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
 481 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
 482 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
 483 %token   MODIFIER_TK
 484
 485 /* Keep those two in order, too */
 486 %token   DECR_TK INCR_TK
 487
 488 /* From now one, things can be in any order */
 489
 490 %token   DEFAULT_TK      IF_TK              THROW_TK
 491 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
 492 %token   THROWS_TK       BREAK_TK           IMPORT_TK
 493 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
 494 %token   VOID_TK         CATCH_TK           INTERFACE_TK
 495 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
 496 %token   SUPER_TK        WHILE_TK           CLASS_TK
 497 %token   SWITCH_TK       CONST_TK           TRY_TK
 498 %token   FOR_TK          NEW_TK             CONTINUE_TK
 499 %token   GOTO_TK         PACKAGE_TK         THIS_TK
 500 %token   ASSERT_TK
 501
 502 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
 503 %token   CHAR_TK         INTEGRAL_TK
 504
 505 %token   FLOAT_TK        DOUBLE_TK          FP_TK
 506
 507 %token   ID_TK
 508
 509 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
 510
 511 %token   ASSIGN_ANY_TK   ASSIGN_TK
 512 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
 513
 514 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
 515 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
 516
 517 %type    <value>        modifiers MODIFIER_TK final synchronized
 518
 519 %type    <node>         super ID_TK identifier
 520 %type    <node>         name simple_name qualified_name
 521 %type    <node>         type_declaration compilation_unit
 522                         field_declaration method_declaration extends_interfaces
 523                         interfaces interface_type_list
 524                         import_declarations package_declaration
 525                         type_declarations interface_body
 526                         interface_member_declaration constant_declaration
 527                         interface_member_declarations interface_type
 528                         abstract_method_declaration
 529 %type    <node>         class_body_declaration class_member_declaration
 530                         static_initializer constructor_declaration block
 531 %type    <node>         class_body_declarations constructor_header
 532 %type    <node>         class_or_interface_type class_type class_type_list
 533                         constructor_declarator explicit_constructor_invocation
 534 %type    <node>         dim_expr dim_exprs this_or_super throws
 535
 536 %type    <node>         variable_declarator_id variable_declarator
 537                         variable_declarators variable_initializer
 538                         variable_initializers constructor_body
 539                         array_initializer
 540
 541 %type    <node>         class_body block_end constructor_block_end
 542 %type    <node>         statement statement_without_trailing_substatement
 543                         labeled_statement if_then_statement label_decl
 544                         if_then_else_statement while_statement for_statement
 545                         statement_nsi labeled_statement_nsi do_statement
 546                         if_then_else_statement_nsi while_statement_nsi
 547                         for_statement_nsi statement_expression_list for_init
 548                         for_update statement_expression expression_statement
 549                         primary_no_new_array expression primary
 550                         array_creation_expression array_type
 551                         class_instance_creation_expression field_access
 552                         method_invocation array_access something_dot_new
 553                         argument_list postfix_expression while_expression
 554                         post_increment_expression post_decrement_expression
 555                         unary_expression_not_plus_minus unary_expression
 556                         pre_increment_expression pre_decrement_expression
 557                         cast_expression
 558                         multiplicative_expression additive_expression
 559                         shift_expression relational_expression
 560                         equality_expression and_expression
 561                         exclusive_or_expression inclusive_or_expression
 562                         conditional_and_expression conditional_or_expression
 563                         conditional_expression assignment_expression
 564                         left_hand_side assignment for_header for_begin
 565                         constant_expression do_statement_begin empty_statement
 566                         switch_statement synchronized_statement throw_statement
 567                         try_statement assert_statement
 568                         switch_expression switch_block
 569                         catches catch_clause catch_clause_parameter finally
 570                         anonymous_class_creation trap_overflow_corner_case
 571 %type    <node>         return_statement break_statement continue_statement
 572
 573 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
 574 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
 575 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 576 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
 577 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
 578 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
 579 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
 580 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
 581 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
 582 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
 583 %type    <operator>     THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
 584 %type    <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
 585 %type    <operator>     NEW_TK ASSERT_TK
 586
 587 %type    <node>         method_body
 588
 589 %type    <node>         literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
 590                         STRING_LIT_TK NULL_TK VOID_TK
 591
 592 %type    <node>         IF_TK WHILE_TK FOR_TK
 593
 594 %type    <node>         formal_parameter_list formal_parameter
 595                         method_declarator method_header
 596
 597 %type    <node>         primitive_type reference_type type
 598                         BOOLEAN_TK INTEGRAL_TK FP_TK
 599
 600 /* Added or modified JDK 1.1 rule types  */
 601 %type    <node>         type_literals
 602
 603 %%
 604 /* 19.2 Production from 2.3: The Syntactic Grammar  */
 605 goal:  compilation_unit
 606                 {}
 607 ;
 608
 609 /* 19.3 Productions from 3: Lexical structure  */
 610 literal:
 611         INT_LIT_TK
 612 |       FP_LIT_TK
 613 |       BOOL_LIT_TK
 614 |       CHAR_LIT_TK
 615 |       STRING_LIT_TK
 616 |       NULL_TK
 617 ;
 618
 619 /* 19.4 Productions from 4: Types, Values and Variables  */
 620 type:
 621         primitive_type
 622 |       reference_type
 623 ;
 624
 625 primitive_type:
 626         INTEGRAL_TK
 627 |       FP_TK
 628 |       BOOLEAN_TK
 629 ;
 630
 631 reference_type:
 632         class_or_interface_type
 633 |       array_type
 634 ;
 635
 636 class_or_interface_type:
 637         name
 638 ;
 639
 640 class_type:
 641         class_or_interface_type /* Default rule */
 642 ;
 643
 644 interface_type:
 645          class_or_interface_type
 646 ;
 647
 648 array_type:
 649         primitive_type dims
 650                 {
 651                   int osb = pop_current_osb (ctxp);
 652                   tree t = build_java_array_type (($1), -1);
 653                   while (--osb)
 654                     t = build_unresolved_array_type (t);
 655                   $$ = t;
 656                 }
 657 |       name dims
 658                 {
 659                   int osb = pop_current_osb (ctxp);
 660                   tree t = $1;
 661                   while (osb--)
 662                     t = build_unresolved_array_type (t);
 663                   $$ = t;
 664                 }
 665 ;
 666
 667 /* 19.5 Productions from 6: Names  */
 668 name:
 669         simple_name             /* Default rule */
 670 |       qualified_name          /* Default rule */
 671 ;
 672
 673 simple_name:
 674         identifier              /* Default rule */
 675 ;
 676
 677 qualified_name:
 678         name DOT_TK identifier
 679                 { $$ = make_qualified_name ($1, $3, $2.location); }
 680 ;
 681
 682 identifier:
 683         ID_TK
 684 ;
 685
 686 /* 19.6: Production from 7: Packages  */
 687 compilation_unit:
 688                 {$$ = NULL;}
 689 |       package_declaration
 690 |       import_declarations
 691 |       type_declarations
 692 |       package_declaration import_declarations
 693 |       package_declaration type_declarations
 694 |       import_declarations type_declarations
 695 |       package_declaration import_declarations type_declarations
 696 ;
 697
 698 import_declarations:
 699         import_declaration
 700                 {
 701                   $$ = NULL;
 702                 }
 703 |       import_declarations import_declaration
 704                 {
 705                   $$ = NULL;
 706                 }
 707 ;
 708
 709 type_declarations:
 710         type_declaration
 711 |       type_declarations type_declaration
 712 ;
 713
 714 package_declaration:
 715         PACKAGE_TK name SC_TK
 716                 {
 717                   ctxp->package = EXPR_WFL_NODE ($2);
 718                   register_package (ctxp->package);
 719                 }
 720 |       PACKAGE_TK error
 721                 {yyerror ("Missing name"); RECOVER;}
 722 |       PACKAGE_TK name error
 723                 {yyerror ("';' expected"); RECOVER;}
 724 ;
 725
 726 import_declaration:
 727         single_type_import_declaration
 728 |       type_import_on_demand_declaration
 729 ;
 730
 731 single_type_import_declaration:
 732         IMPORT_TK name SC_TK
 733                 {
 734                   tree name = EXPR_WFL_NODE ($2), last_name;
 735                   int   i = IDENTIFIER_LENGTH (name)-1;
 736                   const char *last = &IDENTIFIER_POINTER (name)[i];
 737                   while (last != IDENTIFIER_POINTER (name))
 738                     {
 739                       if (last [0] == '.')
 740                         break;
 741                       last--;
 742                     }
 743                   last_name = get_identifier (++last);
 744                   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
 745                     {
 746                       tree err = find_name_in_single_imports (last_name);
 747                       if (err && err != name)
 748                         parse_error_context
 749                           ($2, "Ambiguous class: `%s' and `%s'",
 750                            IDENTIFIER_POINTER (name),
 751                            IDENTIFIER_POINTER (err));
 752                       else
 753                         REGISTER_IMPORT ($2, last_name);
 754                     }
 755                   else
 756                     REGISTER_IMPORT ($2, last_name);
 757                 }
 758 |       IMPORT_TK error
 759                 {yyerror ("Missing name"); RECOVER;}
 760 |       IMPORT_TK name error
 761                 {yyerror ("';' expected"); RECOVER;}
 762 ;
 763
 764 type_import_on_demand_declaration:
 765         IMPORT_TK name DOT_TK MULT_TK SC_TK
 766                 {
 767                   tree name = EXPR_WFL_NODE ($2);
 768                   tree it;
 769                   /* Search for duplicates. */
 770                   for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
 771                     if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
 772                       break;
 773                   /* Don't import the same thing more than once, just ignore
 774                      duplicates (7.5.2) */
 775                   if (! it)
 776                     {
 777                       read_import_dir ($2);
 778                       ctxp->import_demand_list =
 779                         chainon (ctxp->import_demand_list,
 780                                  build_tree_list ($2, NULL_TREE));
 781                     }
 782                 }
 783 |       IMPORT_TK name DOT_TK error
 784                 {yyerror ("'*' expected"); RECOVER;}
 785 |       IMPORT_TK name DOT_TK MULT_TK error
 786                 {yyerror ("';' expected"); RECOVER;}
 787 ;
 788
 789 type_declaration:
 790         class_declaration
 791                 { end_class_declaration (0); }
 792 |       interface_declaration
 793                 { end_class_declaration (0); }
 794 |       empty_statement
 795 |       error
 796                 {
 797                   YYERROR_NOW;
 798                   yyerror ("Class or interface declaration expected");
 799                 }
 800 ;
 801
 802 /* 19.7 Shortened from the original:
 803    modifiers: modifier | modifiers modifier
 804    modifier: any of public...  */
 805 modifiers:
 806         MODIFIER_TK
 807                 {
 808                   $$ = (1 << $1);
 809                 }
 810 |       modifiers MODIFIER_TK
 811                 {
 812                   int acc = (1 << $2);
 813                   if ($$ & acc)
 814                     parse_error_context
 815                       (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
 816                        java_accstring_lookup (acc));
 817                   else
 818                     {
 819                       $$ |= acc;
 820                     }
 821                 }
 822 ;
 823
 824 /* 19.8.1 Production from $8.1: Class Declaration */
 825 class_declaration:
 826         modifiers CLASS_TK identifier super interfaces
 827                 { create_class ($1, $3, $4, $5); }
 828         class_body
 829                 {;}
 830 |       CLASS_TK identifier super interfaces
 831                 { create_class (0, $2, $3, $4); }
 832         class_body
 833                 {;}
 834 |       modifiers CLASS_TK error
 835                 { yyerror ("Missing class name"); RECOVER; }
 836 |       CLASS_TK error
 837                 { yyerror ("Missing class name"); RECOVER; }
 838 |       CLASS_TK identifier error
 839                 {
 840                   if (!ctxp->class_err) yyerror ("'{' expected");
 841                   DRECOVER(class1);
 842                 }
 843 |       modifiers CLASS_TK identifier error
 844                 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
 845 ;
 846
 847 super:
 848                 { $$ = NULL; }
 849 |       EXTENDS_TK class_type
 850                 { $$ = $2; }
 851 |       EXTENDS_TK class_type error
 852                 {yyerror ("'{' expected"); ctxp->class_err=1;}
 853 |       EXTENDS_TK error
 854                 {yyerror ("Missing super class name"); ctxp->class_err=1;}
 855 ;
 856
 857 interfaces:
 858                 { $$ = NULL_TREE; }
 859 |       IMPLEMENTS_TK interface_type_list
 860                 { $$ = $2; }
 861 |       IMPLEMENTS_TK error
 862                 {
 863                   ctxp->class_err=1;
 864                   yyerror ("Missing interface name");
 865                 }
 866 ;
 867
 868 interface_type_list:
 869         interface_type
 870                 {
 871                   ctxp->interface_number = 1;
 872                   $$ = build_tree_list ($1, NULL_TREE);
 873                 }
 874 |       interface_type_list C_TK interface_type
 875                 {
 876                   ctxp->interface_number++;
 877                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
 878                 }
 879 |       interface_type_list C_TK error
 880                 {yyerror ("Missing interface name"); RECOVER;}
 881 ;
 882
 883 class_body:
 884         OCB_TK CCB_TK
 885                 {
 886                   /* Store the location of the `}' when doing xrefs */
 887                   if (flag_emit_xref)
 888                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 889                       EXPR_WFL_ADD_COL ($2.location, 1);
 890                   $$ = GET_CPC ();
 891                 }
 892 |       OCB_TK class_body_declarations CCB_TK
 893                 {
 894                   /* Store the location of the `}' when doing xrefs */
 895                   if (flag_emit_xref)
 896                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 897                       EXPR_WFL_ADD_COL ($3.location, 1);
 898                   $$ = GET_CPC ();
 899                 }
 900 ;
 901
 902 class_body_declarations:
 903         class_body_declaration
 904 |       class_body_declarations class_body_declaration
 905 ;
 906
 907 class_body_declaration:
 908         class_member_declaration
 909 |       static_initializer
 910 |       constructor_declaration
 911 |       block                   /* Added, JDK1.1, instance initializer */
 912                 {
 913                   if ($1 != empty_stmt_node)
 914                     {
 915                       TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
 916                       SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
 917                     }
 918                 }
 919 ;
 920
 921 class_member_declaration:
 922         field_declaration
 923 |       method_declaration
 924 |       class_declaration       /* Added, JDK1.1 inner classes */
 925                 { end_class_declaration (1); }
 926 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
 927                 { end_class_declaration (1); }
 928 |       empty_statement
 929 ;
 930
 931 /* 19.8.2 Productions from 8.3: Field Declarations  */
 932 field_declaration:
 933         type variable_declarators SC_TK
 934                 { register_fields (0, $1, $2); }
 935 |       modifiers type variable_declarators SC_TK
 936                 {
 937                   check_modifiers
 938                     ("Illegal modifier `%s' for field declaration",
 939                      $1, FIELD_MODIFIERS);
 940                   check_modifiers_consistency ($1);
 941                   register_fields ($1, $2, $3);
 942                 }
 943 ;
 944
 945 variable_declarators:
 946         /* Should we use build_decl_list () instead ? FIXME */
 947         variable_declarator     /* Default rule */
 948 |       variable_declarators C_TK variable_declarator
 949                 { $$ = chainon ($1, $3); }
 950 |       variable_declarators C_TK error
 951                 {yyerror ("Missing term"); RECOVER;}
 952 ;
 953
 954 variable_declarator:
 955         variable_declarator_id
 956                 { $$ = build_tree_list ($1, NULL_TREE); }
 957 |       variable_declarator_id ASSIGN_TK variable_initializer
 958                 {
 959                   if (java_error_count)
 960                     $3 = NULL_TREE;
 961                   $$ = build_tree_list
 962                     ($1, build_assignment ($2.token, $2.location, $1, $3));
 963                 }
 964 |       variable_declarator_id ASSIGN_TK error
 965                 {
 966                   yyerror ("Missing variable initializer");
 967                   $$ = build_tree_list ($1, NULL_TREE);
 968                   RECOVER;
 969                 }
 970 |       variable_declarator_id ASSIGN_TK variable_initializer error
 971                 {
 972                   yyerror ("';' expected");
 973                   $$ = build_tree_list ($1, NULL_TREE);
 974                   RECOVER;
 975                 }
 976 ;
 977
 978 variable_declarator_id:
 979         identifier
 980 |       variable_declarator_id OSB_TK CSB_TK
 981                 { $$ = build_unresolved_array_type ($1); }
 982 |       identifier error
 983                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
 984 |       variable_declarator_id OSB_TK error
 985                 {
 986                   yyerror ("']' expected");
 987                   DRECOVER(vdi);
 988                 }
 989 |       variable_declarator_id CSB_TK error
 990                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
 991 ;
 992
 993 variable_initializer:
 994         expression
 995 |       array_initializer
 996 ;
 997
 998 /* 19.8.3 Productions from 8.4: Method Declarations  */
 999 method_declaration:
1000         method_header
1001                 {
1002                   current_function_decl = $1;
1003                   if (current_function_decl
1004                       && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1005                     source_start_java_method (current_function_decl);
1006                   else
1007                     current_function_decl = NULL_TREE;
1008                 }
1009         method_body
1010                 { finish_method_declaration ($3); }
1011 |       method_header error
1012                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1013 ;
1014
1015 method_header:
1016         type method_declarator throws
1017                 { $$ = method_header (0, $1, $2, $3); }
1018 |       VOID_TK method_declarator throws
1019                 { $$ = method_header (0, void_type_node, $2, $3); }
1020 |       modifiers type method_declarator throws
1021                 { $$ = method_header ($1, $2, $3, $4); }
1022 |       modifiers VOID_TK method_declarator throws
1023                 { $$ = method_header ($1, void_type_node, $3, $4); }
1024 |       type error
1025                 {
1026                   yyerror ("Invalid method declaration, method name required");
1027                   RECOVER;
1028                 }
1029 |       modifiers type error
1030                 {
1031                   yyerror ("Identifier expected");
1032                   RECOVER;
1033                 }
1034 |       VOID_TK error
1035                 {
1036                   yyerror ("Identifier expected");
1037                   RECOVER;
1038                 }
1039 |       modifiers VOID_TK error
1040                 {
1041                   yyerror ("Identifier expected");
1042                   RECOVER;
1043                 }
1044 |       modifiers error
1045                 {
1046                   yyerror ("Invalid method declaration, return type required");
1047                   RECOVER;
1048                 }
1049 ;
1050
1051 method_declarator:
1052         identifier OP_TK CP_TK
1053                 {
1054                   ctxp->formal_parameter_number = 0;
1055                   $$ = method_declarator ($1, NULL_TREE);
1056                 }
1057 |       identifier OP_TK formal_parameter_list CP_TK
1058                 { $$ = method_declarator ($1, $3); }
1059 |       method_declarator OSB_TK CSB_TK
1060                 {
1061                   EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1062                   TREE_PURPOSE ($1) =
1063                     build_unresolved_array_type (TREE_PURPOSE ($1));
1064                   parse_warning_context
1065                     (wfl_operator,
1066                      "Discouraged form of returned type specification");
1067                 }
1068 |       identifier OP_TK error
1069                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1070 |       method_declarator OSB_TK error
1071                 {yyerror ("']' expected"); RECOVER;}
1072 ;
1073
1074 formal_parameter_list:
1075         formal_parameter
1076                 {
1077                   ctxp->formal_parameter_number = 1;
1078                 }
1079 |       formal_parameter_list C_TK formal_parameter
1080                 {
1081                   ctxp->formal_parameter_number += 1;
1082                   $$ = chainon ($1, $3);
1083                 }
1084 |       formal_parameter_list C_TK error
1085                 { yyerror ("Missing formal parameter term"); RECOVER; }
1086 ;
1087
1088 formal_parameter:
1089         type variable_declarator_id
1090                 {
1091                   $$ = build_tree_list ($2, $1);
1092                 }
1093 |       final type variable_declarator_id /* Added, JDK1.1 final parms */
1094                 {
1095                   $$ = build_tree_list ($3, $2);
1096                   ARG_FINAL_P ($$) = 1;
1097                 }
1098 |       type error
1099                 {
1100                   yyerror ("Missing identifier"); RECOVER;
1101                   $$ = NULL_TREE;
1102                 }
1103 |       final type error
1104                 {
1105                   yyerror ("Missing identifier"); RECOVER;
1106                   $$ = NULL_TREE;
1107                 }
1108 ;
1109
1110 final:
1111         modifiers
1112                 {
1113                   check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1114                                    $1, ACC_FINAL);
1115                   if ($1 != ACC_FINAL)
1116                     MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1117                 }
1118 ;
1119
1120 throws:
1121                 { $$ = NULL_TREE; }
1122 |       THROWS_TK class_type_list
1123                 { $$ = $2; }
1124 |       THROWS_TK error
1125                 {yyerror ("Missing class type term"); RECOVER;}
1126 ;
1127
1128 class_type_list:
1129         class_type
1130                 { $$ = build_tree_list ($1, $1); }
1131 |       class_type_list C_TK class_type
1132                 { $$ = tree_cons ($3, $3, $1); }
1133 |       class_type_list C_TK error
1134                 {yyerror ("Missing class type term"); RECOVER;}
1135 ;
1136
1137 method_body:
1138         block
1139 |       SC_TK { $$ = NULL_TREE; }
1140 ;
1141
1142 /* 19.8.4 Productions from 8.5: Static Initializers  */
1143 static_initializer:
1144         static block
1145                 {
1146                   TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1147                   SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1148                   current_static_block = NULL_TREE;
1149                 }
1150 ;
1151
1152 static:                         /* Test lval.sub_token here */
1153         modifiers
1154                 {
1155                   check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1156                   /* Can't have a static initializer in an innerclass */
1157                   if ($1 | ACC_STATIC &&
1158                       GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1159                     parse_error_context
1160                       (MODIFIER_WFL (STATIC_TK),
1161                        "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1162                        IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1163                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1164                 }
1165 ;
1166
1167 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1168 constructor_declaration:
1169         constructor_header
1170                 {
1171                   current_function_decl = $1;
1172                   source_start_java_method (current_function_decl);
1173                 }
1174         constructor_body
1175                 { finish_method_declaration ($3); }
1176 ;
1177
1178 constructor_header:
1179         constructor_declarator throws
1180                 { $$ = method_header (0, NULL_TREE, $1, $2); }
1181 |       modifiers constructor_declarator throws
1182                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1183 ;
1184
1185 constructor_declarator:
1186         simple_name OP_TK CP_TK
1187                 {
1188                   ctxp->formal_parameter_number = 0;
1189                   $$ = method_declarator ($1, NULL_TREE);
1190                 }
1191 |       simple_name OP_TK formal_parameter_list CP_TK
1192                 { $$ = method_declarator ($1, $3); }
1193 ;
1194
1195 constructor_body:
1196         /* Unlike regular method, we always need a complete (empty)
1197            body so we can safely perform all the required code
1198            addition (super invocation and field initialization) */
1199         block_begin constructor_block_end
1200                 {
1201                   BLOCK_EXPR_BODY ($2) = empty_stmt_node;
1202                   $$ = $2;
1203                 }
1204 |       block_begin explicit_constructor_invocation constructor_block_end
1205                 { $$ = $3; }
1206 |       block_begin block_statements constructor_block_end
1207                 { $$ = $3; }
1208 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1209                 { $$ = $4; }
1210 ;
1211
1212 constructor_block_end:
1213         block_end
1214 ;
1215
1216 /* Error recovery for that rule moved down expression_statement: rule.  */
1217 explicit_constructor_invocation:
1218         this_or_super OP_TK CP_TK SC_TK
1219                 {
1220                   $$ = build_method_invocation ($1, NULL_TREE);
1221                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1222                   $$ = java_method_add_stmt (current_function_decl, $$);
1223                 }
1224 |       this_or_super OP_TK argument_list CP_TK SC_TK
1225                 {
1226                   $$ = build_method_invocation ($1, $3);
1227                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1228                   $$ = java_method_add_stmt (current_function_decl, $$);
1229                 }
1230         /* Added, JDK1.1 inner classes. Modified because the rule
1231            'primary' couldn't work.  */
1232 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1233                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1234 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1235                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1236 ;
1237
1238 this_or_super:                  /* Added, simplifies error diagnostics */
1239         THIS_TK
1240                 {
1241                   tree wfl = build_wfl_node (this_identifier_node);
1242                   EXPR_WFL_LINECOL (wfl) = $1.location;
1243                   $$ = wfl;
1244                 }
1245 |       SUPER_TK
1246                 {
1247                   tree wfl = build_wfl_node (super_identifier_node);
1248                   EXPR_WFL_LINECOL (wfl) = $1.location;
1249                   $$ = wfl;
1250                 }
1251 ;
1252
1253 /* 19.9 Productions from 9: Interfaces  */
1254 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1255 interface_declaration:
1256         INTERFACE_TK identifier
1257                 { create_interface (0, $2, NULL_TREE); }
1258         interface_body
1259                 { ; }
1260 |       modifiers INTERFACE_TK identifier
1261                 { create_interface ($1, $3, NULL_TREE); }
1262         interface_body
1263                 { ; }
1264 |       INTERFACE_TK identifier extends_interfaces
1265                 { create_interface (0, $2, $3); }
1266         interface_body
1267                 { ; }
1268 |       modifiers INTERFACE_TK identifier extends_interfaces
1269                 { create_interface ($1, $3, $4); }
1270         interface_body
1271                 { ; }
1272 |       INTERFACE_TK identifier error
1273                 { yyerror ("'{' expected"); RECOVER; }
1274 |       modifiers INTERFACE_TK identifier error
1275                 { yyerror ("'{' expected"); RECOVER; }
1276 ;
1277
1278 extends_interfaces:
1279         EXTENDS_TK interface_type
1280                 {
1281                   ctxp->interface_number = 1;
1282                   $$ = build_tree_list ($2, NULL_TREE);
1283                 }
1284 |       extends_interfaces C_TK interface_type
1285                 {
1286                   ctxp->interface_number++;
1287                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1288                 }
1289 |       EXTENDS_TK error
1290                 {yyerror ("Invalid interface type"); RECOVER;}
1291 |       extends_interfaces C_TK error
1292                 {yyerror ("Missing term"); RECOVER;}
1293 ;
1294
1295 interface_body:
1296         OCB_TK CCB_TK
1297                 { $$ = NULL_TREE; }
1298 |       OCB_TK interface_member_declarations CCB_TK
1299                 { $$ = NULL_TREE; }
1300 ;
1301
1302 interface_member_declarations:
1303         interface_member_declaration
1304 |       interface_member_declarations interface_member_declaration
1305 ;
1306
1307 interface_member_declaration:
1308         constant_declaration
1309 |       abstract_method_declaration
1310 |       class_declaration       /* Added, JDK1.1 inner classes */
1311                 { end_class_declaration (1); }
1312 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
1313                 { end_class_declaration (1); }
1314 ;
1315
1316 constant_declaration:
1317         field_declaration
1318 ;
1319
1320 abstract_method_declaration:
1321         method_header SC_TK
1322                 {
1323                   check_abstract_method_header ($1);
1324                   current_function_decl = NULL_TREE; /* FIXME ? */
1325                 }
1326 |       method_header error
1327                 {yyerror ("';' expected"); RECOVER;}
1328 ;
1329
1330 /* 19.10 Productions from 10: Arrays  */
1331 array_initializer:
1332         OCB_TK CCB_TK
1333                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1334 |       OCB_TK C_TK CCB_TK
1335                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1336 |       OCB_TK variable_initializers CCB_TK
1337                 { $$ = build_new_array_init ($1.location, $2); }
1338 |       OCB_TK variable_initializers C_TK CCB_TK
1339                 { $$ = build_new_array_init ($1.location, $2); }
1340 ;
1341
1342 variable_initializers:
1343         variable_initializer
1344                 {
1345                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1346                                   $1, NULL_TREE);
1347                 }
1348 |       variable_initializers C_TK variable_initializer
1349                 {
1350                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1351                 }
1352 |       variable_initializers C_TK error
1353                 {yyerror ("Missing term"); RECOVER;}
1354 ;
1355
1356 /* 19.11 Production from 14: Blocks and Statements  */
1357 block:
1358         block_begin block_end
1359                 { $$ = $2; }
1360 |       block_begin block_statements block_end
1361                 { $$ = $3; }
1362 ;
1363
1364 block_begin:
1365         OCB_TK
1366                 { enter_block (); }
1367 ;
1368
1369 block_end:
1370         CCB_TK
1371                 {
1372                   maybe_absorb_scoping_blocks ();
1373                   /* Store the location of the `}' when doing xrefs */
1374                   if (current_function_decl && flag_emit_xref)
1375                     DECL_END_SOURCE_LINE (current_function_decl) =
1376                       EXPR_WFL_ADD_COL ($1.location, 1);
1377                   $$ = exit_block ();
1378                   if (!BLOCK_SUBBLOCKS ($$))
1379                     BLOCK_SUBBLOCKS ($$) = empty_stmt_node;
1380                 }
1381 ;
1382
1383 block_statements:
1384         block_statement
1385 |       block_statements block_statement
1386 ;
1387
1388 block_statement:
1389         local_variable_declaration_statement
1390 |       statement
1391                 { java_method_add_stmt (current_function_decl, $1); }
1392 |       class_declaration       /* Added, JDK1.1 local classes */
1393                 {
1394                   LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1395                   end_class_declaration (1);
1396                 }
1397 ;
1398
1399 local_variable_declaration_statement:
1400         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1401 ;
1402
1403 local_variable_declaration:
1404         type variable_declarators
1405                 { declare_local_variables (0, $1, $2); }
1406 |       final type variable_declarators /* Added, JDK1.1 final locals */
1407                 { declare_local_variables ($1, $2, $3); }
1408 ;
1409
1410 statement:
1411         statement_without_trailing_substatement
1412 |       labeled_statement
1413 |       if_then_statement
1414 |       if_then_else_statement
1415 |       while_statement
1416 |       for_statement
1417                 { $$ = exit_block (); }
1418 ;
1419
1420 statement_nsi:
1421         statement_without_trailing_substatement
1422 |       labeled_statement_nsi
1423 |       if_then_else_statement_nsi
1424 |       while_statement_nsi
1425 |       for_statement_nsi
1426                 { $$ = exit_block (); }
1427 ;
1428
1429 statement_without_trailing_substatement:
1430         block
1431 |       empty_statement
1432 |       expression_statement
1433 |       switch_statement
1434 |       do_statement
1435 |       break_statement
1436 |       continue_statement
1437 |       return_statement
1438 |       synchronized_statement
1439 |       throw_statement
1440 |       try_statement
1441 |       assert_statement
1442 ;
1443
1444 empty_statement:
1445         SC_TK
1446                 {
1447                   if (flag_extraneous_semicolon
1448                       && ! current_static_block
1449                       && (! current_function_decl ||
1450                           /* Verify we're not in a inner class declaration */
1451                           (GET_CPC () != TYPE_NAME
1452                            (DECL_CONTEXT (current_function_decl)))))
1453
1454                     {
1455                       EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1456                       parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1457                     }
1458                   $$ = empty_stmt_node;
1459                 }
1460 ;
1461
1462 label_decl:
1463         identifier REL_CL_TK
1464                 {
1465                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1466                                             EXPR_WFL_NODE ($1));
1467                   pushlevel (2);
1468                   push_labeled_block ($$);
1469                   PUSH_LABELED_BLOCK ($$);
1470                 }
1471 ;
1472
1473 labeled_statement:
1474         label_decl statement
1475                 { $$ = finish_labeled_statement ($1, $2); }
1476 |       identifier error
1477                 {yyerror ("':' expected"); RECOVER;}
1478 ;
1479
1480 labeled_statement_nsi:
1481         label_decl statement_nsi
1482                 { $$ = finish_labeled_statement ($1, $2); }
1483 ;
1484
1485 /* We concentrate here a bunch of error handling rules that we couldn't write
1486    earlier, because expression_statement catches a missing ';'.  */
1487 expression_statement:
1488         statement_expression SC_TK
1489                 {
1490                   /* We have a statement. Generate a WFL around it so
1491                      we can debug it */
1492                   $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1493                   /* We know we have a statement, so set the debug
1494                      info to be eventually generate here. */
1495                   $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1496                 }
1497 |       error SC_TK
1498                 {
1499                   YYNOT_TWICE yyerror ("Invalid expression statement");
1500                   DRECOVER (expr_stmt);
1501                 }
1502 |       error OCB_TK
1503                 {
1504                   YYNOT_TWICE yyerror ("Invalid expression statement");
1505                   DRECOVER (expr_stmt);
1506                 }
1507 |       error CCB_TK
1508                 {
1509                   YYNOT_TWICE yyerror ("Invalid expression statement");
1510                   DRECOVER (expr_stmt);
1511                 }
1512 |       this_or_super OP_TK error
1513                 {yyerror ("')' expected"); RECOVER;}
1514 |       this_or_super OP_TK CP_TK error
1515                 {
1516                   parse_ctor_invocation_error ();
1517                   RECOVER;
1518                 }
1519 |       this_or_super OP_TK argument_list error
1520                 {yyerror ("')' expected"); RECOVER;}
1521 |       this_or_super OP_TK argument_list CP_TK error
1522                 {
1523                   parse_ctor_invocation_error ();
1524                   RECOVER;
1525                 }
1526 |       name DOT_TK SUPER_TK error
1527                 {yyerror ("'(' expected"); RECOVER;}
1528 |       name DOT_TK SUPER_TK OP_TK error
1529                 {yyerror ("')' expected"); RECOVER;}
1530 |       name DOT_TK SUPER_TK OP_TK argument_list error
1531                 {yyerror ("')' expected"); RECOVER;}
1532 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1533                 {yyerror ("';' expected"); RECOVER;}
1534 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1535                 {yyerror ("';' expected"); RECOVER;}
1536 ;
1537
1538 statement_expression:
1539         assignment
1540 |       pre_increment_expression
1541 |       pre_decrement_expression
1542 |       post_increment_expression
1543 |       post_decrement_expression
1544 |       method_invocation
1545 |       class_instance_creation_expression
1546 ;
1547
1548 if_then_statement:
1549         IF_TK OP_TK expression CP_TK statement
1550                 {
1551                   $$ = build_if_else_statement ($2.location, $3,
1552                                                 $5, NULL_TREE);
1553                 }
1554 |       IF_TK error
1555                 {yyerror ("'(' expected"); RECOVER;}
1556 |       IF_TK OP_TK error
1557                 {yyerror ("Missing term"); RECOVER;}
1558 |       IF_TK OP_TK expression error
1559                 {yyerror ("')' expected"); RECOVER;}
1560 ;
1561
1562 if_then_else_statement:
1563         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1564                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1565 ;
1566
1567 if_then_else_statement_nsi:
1568         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1569                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1570 ;
1571
1572 switch_statement:
1573         switch_expression
1574                 {
1575                   enter_block ();
1576                 }
1577         switch_block
1578                 {
1579                   /* Make into "proper list" of COMPOUND_EXPRs.
1580                      I.e. make the last statement also have its own
1581                      COMPOUND_EXPR. */
1582                   maybe_absorb_scoping_blocks ();
1583                   TREE_OPERAND ($1, 1) = exit_block ();
1584                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1585                 }
1586 ;
1587
1588 switch_expression:
1589         SWITCH_TK OP_TK expression CP_TK
1590                 {
1591                   $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1592                   EXPR_WFL_LINECOL ($$) = $2.location;
1593                 }
1594 |       SWITCH_TK error
1595                 {yyerror ("'(' expected"); RECOVER;}
1596 |       SWITCH_TK OP_TK error
1597                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1598 |       SWITCH_TK OP_TK expression CP_TK error
1599                 {yyerror ("'{' expected"); RECOVER;}
1600 ;
1601
1602 /* Default assignment is there to avoid type node on switch_block
1603    node. */
1604
1605 switch_block:
1606         OCB_TK CCB_TK
1607                 { $$ = NULL_TREE; }
1608 |       OCB_TK switch_labels CCB_TK
1609                 { $$ = NULL_TREE; }
1610 |       OCB_TK switch_block_statement_groups CCB_TK
1611                 { $$ = NULL_TREE; }
1612 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1613                 { $$ = NULL_TREE; }
1614 ;
1615
1616 switch_block_statement_groups:
1617         switch_block_statement_group
1618 |       switch_block_statement_groups switch_block_statement_group
1619 ;
1620
1621 switch_block_statement_group:
1622         switch_labels block_statements
1623 ;
1624
1625 switch_labels:
1626         switch_label
1627 |       switch_labels switch_label
1628 ;
1629
1630 switch_label:
1631         CASE_TK constant_expression REL_CL_TK
1632                 {
1633                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1634                   EXPR_WFL_LINECOL (lab) = $1.location;
1635                   java_method_add_stmt (current_function_decl, lab);
1636                 }
1637 |       DEFAULT_TK REL_CL_TK
1638                 {
1639                   tree lab = make_node (DEFAULT_EXPR);
1640                   EXPR_WFL_LINECOL (lab) = $1.location;
1641                   java_method_add_stmt (current_function_decl, lab);
1642                 }
1643 |       CASE_TK error
1644                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1645 |       CASE_TK constant_expression error
1646                 {yyerror ("':' expected"); RECOVER;}
1647 |       DEFAULT_TK error
1648                 {yyerror ("':' expected"); RECOVER;}
1649 ;
1650
1651 while_expression:
1652         WHILE_TK OP_TK expression CP_TK
1653                 {
1654                   tree body = build_loop_body ($2.location, $3, 0);
1655                   $$ = build_new_loop (body);
1656                 }
1657 ;
1658
1659 while_statement:
1660         while_expression statement
1661                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1662 |       WHILE_TK error
1663                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1664 |       WHILE_TK OP_TK error
1665                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1666 |       WHILE_TK OP_TK expression error
1667                 {yyerror ("')' expected"); RECOVER;}
1668 ;
1669
1670 while_statement_nsi:
1671         while_expression statement_nsi
1672                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1673 ;
1674
1675 do_statement_begin:
1676         DO_TK
1677                 {
1678                   tree body = build_loop_body (0, NULL_TREE, 1);
1679                   $$ = build_new_loop (body);
1680                 }
1681         /* Need error handing here. FIXME */
1682 ;
1683
1684 do_statement:
1685         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1686                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1687 ;
1688
1689 for_statement:
1690         for_begin SC_TK expression SC_TK for_update CP_TK statement
1691                 {
1692                   if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1693                     $3 = build_wfl_node ($3);
1694                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1695                 }
1696 |       for_begin SC_TK SC_TK for_update CP_TK statement
1697                 {
1698                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1699                   /* We have not condition, so we get rid of the EXIT_EXPR */
1700                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1701                     empty_stmt_node;
1702                 }
1703 |       for_begin SC_TK error
1704                 {yyerror ("Invalid control expression"); RECOVER;}
1705 |       for_begin SC_TK expression SC_TK error
1706                 {yyerror ("Invalid update expression"); RECOVER;}
1707 |       for_begin SC_TK SC_TK error
1708                 {yyerror ("Invalid update expression"); RECOVER;}
1709 ;
1710
1711 for_statement_nsi:
1712         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1713                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1714 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1715                 {
1716                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1717                   /* We have not condition, so we get rid of the EXIT_EXPR */
1718                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1719                     empty_stmt_node;
1720                 }
1721 ;
1722
1723 for_header:
1724         FOR_TK OP_TK
1725                 {
1726                   /* This scope defined for local variable that may be
1727                      defined within the scope of the for loop */
1728                   enter_block ();
1729                 }
1730 |       FOR_TK error
1731                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1732 |       FOR_TK OP_TK error
1733                 {yyerror ("Invalid init statement"); RECOVER;}
1734 ;
1735
1736 for_begin:
1737         for_header for_init
1738                 {
1739                   /* We now declare the loop body. The loop is
1740                      declared as a for loop. */
1741                   tree body = build_loop_body (0, NULL_TREE, 0);
1742                   $$ =  build_new_loop (body);
1743                   FOR_LOOP_P ($$) = 1;
1744                   /* The loop is added to the current block the for
1745                      statement is defined within */
1746                   java_method_add_stmt (current_function_decl, $$);
1747                 }
1748 ;
1749 for_init:                       /* Can be empty */
1750                 { $$ = empty_stmt_node; }
1751 |       statement_expression_list
1752                 {
1753                   /* Init statement recorded within the previously
1754                      defined block scope */
1755                   $$ = java_method_add_stmt (current_function_decl, $1);
1756                 }
1757 |       local_variable_declaration
1758                 {
1759                   /* Local variable are recorded within the previously
1760                      defined block scope */
1761                   $$ = NULL_TREE;
1762                 }
1763 |       statement_expression_list error
1764                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1765 ;
1766
1767 for_update:                     /* Can be empty */
1768                 {$$ = empty_stmt_node;}
1769 |       statement_expression_list
1770                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1771 ;
1772
1773 statement_expression_list:
1774         statement_expression
1775                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1776 |       statement_expression_list C_TK statement_expression
1777                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1778 |       statement_expression_list C_TK error
1779                 {yyerror ("Missing term"); RECOVER;}
1780 ;
1781
1782 break_statement:
1783         BREAK_TK SC_TK
1784                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1785 |       BREAK_TK identifier SC_TK
1786                 { $$ = build_bc_statement ($1.location, 1, $2); }
1787 |       BREAK_TK error
1788                 {yyerror ("Missing term"); RECOVER;}
1789 |       BREAK_TK identifier error
1790                 {yyerror ("';' expected"); RECOVER;}
1791 ;
1792
1793 continue_statement:
1794         CONTINUE_TK SC_TK
1795                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1796 |       CONTINUE_TK identifier SC_TK
1797                 { $$ = build_bc_statement ($1.location, 0, $2); }
1798 |       CONTINUE_TK error
1799                 {yyerror ("Missing term"); RECOVER;}
1800 |       CONTINUE_TK identifier error
1801                 {yyerror ("';' expected"); RECOVER;}
1802 ;
1803
1804 return_statement:
1805         RETURN_TK SC_TK
1806                 { $$ = build_return ($1.location, NULL_TREE); }
1807 |       RETURN_TK expression SC_TK
1808                 { $$ = build_return ($1.location, $2); }
1809 |       RETURN_TK error
1810                 {yyerror ("Missing term"); RECOVER;}
1811 |       RETURN_TK expression error
1812                 {yyerror ("';' expected"); RECOVER;}
1813 ;
1814
1815 throw_statement:
1816         THROW_TK expression SC_TK
1817                 {
1818                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1819                   EXPR_WFL_LINECOL ($$) = $1.location;
1820                 }
1821 |       THROW_TK error
1822                 {yyerror ("Missing term"); RECOVER;}
1823 |       THROW_TK expression error
1824                 {yyerror ("';' expected"); RECOVER;}
1825 ;
1826
1827 assert_statement:
1828         ASSERT_TK expression REL_CL_TK expression SC_TK
1829                 {
1830                   $$ = build_assertion ($1.location, $2, $4);
1831                 }
1832 |       ASSERT_TK expression SC_TK
1833                 {
1834                   $$ = build_assertion ($1.location, $2, NULL_TREE);
1835                 }
1836 |       ASSERT_TK error
1837                 {yyerror ("Missing term"); RECOVER;}
1838 |       ASSERT_TK expression error
1839                 {yyerror ("';' expected"); RECOVER;}
1840 ;
1841
1842 synchronized_statement:
1843         synchronized OP_TK expression CP_TK block
1844                 {
1845                   $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1846                   EXPR_WFL_LINECOL ($$) =
1847                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1848                 }
1849 |       synchronized OP_TK expression CP_TK error
1850                 {yyerror ("'{' expected"); RECOVER;}
1851 |       synchronized error
1852                 {yyerror ("'(' expected"); RECOVER;}
1853 |       synchronized OP_TK error CP_TK
1854                 {yyerror ("Missing term"); RECOVER;}
1855 |       synchronized OP_TK error
1856                 {yyerror ("Missing term"); RECOVER;}
1857 ;
1858
1859 synchronized:
1860         modifiers
1861                 {
1862                   check_modifiers (
1863              "Illegal modifier `%s'. Only `synchronized' was expected here",
1864                                    $1, ACC_SYNCHRONIZED);
1865                   if ($1 != ACC_SYNCHRONIZED)
1866                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1867                       build_wfl_node (NULL_TREE);
1868                 }
1869 ;
1870
1871 try_statement:
1872         TRY_TK block catches
1873                 { $$ = build_try_statement ($1.location, $2, $3); }
1874 |       TRY_TK block finally
1875                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1876 |       TRY_TK block catches finally
1877                 { $$ = build_try_finally_statement
1878                     ($1.location, build_try_statement ($1.location,
1879                                                        $2, $3), $4);
1880                 }
1881 |       TRY_TK error
1882                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1883 ;
1884
1885 catches:
1886         catch_clause
1887 |       catches catch_clause
1888                 {
1889                   TREE_CHAIN ($2) = $1;
1890                   $$ = $2;
1891                 }
1892 ;
1893
1894 catch_clause:
1895         catch_clause_parameter block
1896                 {
1897                   java_method_add_stmt (current_function_decl, $2);
1898                   exit_block ();
1899                   $$ = $1;
1900                 }
1901 ;
1902
1903 catch_clause_parameter:
1904         CATCH_TK OP_TK formal_parameter CP_TK
1905                 {
1906                   /* We add a block to define a scope for
1907                      formal_parameter (CCBP). The formal parameter is
1908                      declared initialized by the appropriate function
1909                      call */
1910                   tree ccpb;
1911                   tree init;
1912                   if ($3)
1913                     {
1914                       ccpb = enter_block ();
1915                       init = build_assignment
1916                         (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1917                          build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1918                       declare_local_variables (0, TREE_VALUE ($3),
1919                                                build_tree_list
1920                                                (TREE_PURPOSE ($3), init));
1921                       $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1922                       EXPR_WFL_LINECOL ($$) = $1.location;
1923                     }
1924                   else
1925                     {
1926                       $$ = error_mark_node;
1927                     }
1928                 }
1929 |       CATCH_TK error
1930                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1931 |       CATCH_TK OP_TK error
1932                 {
1933                   yyerror ("Missing term or ')' expected");
1934                   RECOVER; $$ = NULL_TREE;
1935                 }
1936 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1937                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1938 ;
1939
1940 finally:
1941         FINALLY_TK block
1942                 { $$ = $2; }
1943 |       FINALLY_TK error
1944                 {yyerror ("'{' expected"); RECOVER; }
1945 ;
1946
1947 /* 19.12 Production from 15: Expressions  */
1948 primary:
1949         primary_no_new_array
1950 |       array_creation_expression
1951 ;
1952
1953 primary_no_new_array:
1954         literal
1955 |       THIS_TK
1956                 { $$ = build_this ($1.location); }
1957 |       OP_TK expression CP_TK
1958                 {$$ = $2;}
1959 |       class_instance_creation_expression
1960 |       field_access
1961 |       method_invocation
1962 |       array_access
1963 |       type_literals
1964         /* Added, JDK1.1 inner classes. Documentation is wrong
1965            refering to a 'ClassName' (class_name) rule that doesn't
1966            exist. Used name: instead.  */
1967 |       name DOT_TK THIS_TK
1968                 {
1969                   tree wfl = build_wfl_node (this_identifier_node);
1970                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1971                 }
1972 |       OP_TK expression error
1973                 {yyerror ("')' expected"); RECOVER;}
1974 |       name DOT_TK error
1975                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1976 |       primitive_type DOT_TK error
1977                 {yyerror ("'class' expected" ); RECOVER;}
1978 |       VOID_TK DOT_TK error
1979                 {yyerror ("'class' expected" ); RECOVER;}
1980 ;
1981
1982 type_literals:
1983         name DOT_TK CLASS_TK
1984                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1985 |       array_type DOT_TK CLASS_TK
1986                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1987 |       primitive_type DOT_TK CLASS_TK
1988                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1989 |       VOID_TK DOT_TK CLASS_TK
1990                 {
1991                    $$ = build_incomplete_class_ref ($2.location,
1992                                                    void_type_node);
1993                 }
1994 ;
1995
1996 class_instance_creation_expression:
1997         NEW_TK class_type OP_TK argument_list CP_TK
1998                 { $$ = build_new_invocation ($2, $4); }
1999 |       NEW_TK class_type OP_TK CP_TK
2000                 { $$ = build_new_invocation ($2, NULL_TREE); }
2001 |       anonymous_class_creation
2002         /* Added, JDK1.1 inner classes, modified to use name or
2003            primary instead of primary solely which couldn't work in
2004            all situations.  */
2005 |       something_dot_new identifier OP_TK CP_TK
2006                 {
2007                   tree ctor = build_new_invocation ($2, NULL_TREE);
2008                   $$ = make_qualified_primary ($1, ctor,
2009                                                EXPR_WFL_LINECOL ($1));
2010                 }
2011 |       something_dot_new identifier OP_TK CP_TK class_body
2012 |       something_dot_new identifier OP_TK argument_list CP_TK
2013                 {
2014                   tree ctor = build_new_invocation ($2, $4);
2015                   $$ = make_qualified_primary ($1, ctor,
2016                                                EXPR_WFL_LINECOL ($1));
2017                 }
2018 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2019 |       NEW_TK error SC_TK
2020                 {yyerror ("'(' expected"); DRECOVER(new_1);}
2021 |       NEW_TK class_type error
2022                 {yyerror ("'(' expected"); RECOVER;}
2023 |       NEW_TK class_type OP_TK error
2024                 {yyerror ("')' or term expected"); RECOVER;}
2025 |       NEW_TK class_type OP_TK argument_list error
2026                 {yyerror ("')' expected"); RECOVER;}
2027 |       something_dot_new error
2028                 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2029 |       something_dot_new identifier error
2030                 {yyerror ("'(' expected"); RECOVER;}
2031 ;
2032
2033 /* Created after JDK1.1 rules originally added to
2034    class_instance_creation_expression, but modified to use
2035    'class_type' instead of 'TypeName' (type_name) which is mentioned
2036    in the documentation but doesn't exist. */
2037
2038 anonymous_class_creation:
2039         NEW_TK class_type OP_TK argument_list CP_TK
2040                 { create_anonymous_class ($1.location, $2); }
2041         class_body
2042                 {
2043                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2044                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2045
2046                   end_class_declaration (1);
2047
2048                   /* Now we can craft the new expression */
2049                   $$ = build_new_invocation (id, $4);
2050
2051                   /* Note that we can't possibly be here if
2052                      `class_type' is an interface (in which case the
2053                      anonymous class extends Object and implements
2054                      `class_type', hence its constructor can't have
2055                      arguments.) */
2056
2057                   /* Otherwise, the innerclass must feature a
2058                      constructor matching `argument_list'. Anonymous
2059                      classes are a bit special: it's impossible to
2060                      define constructor for them, hence constructors
2061                      must be generated following the hints provided by
2062                      the `new' expression. Whether a super constructor
2063                      of that nature exists or not is to be verified
2064                      later on in verify_constructor_super.
2065
2066                      It's during the expansion of a `new' statement
2067                      refering to an anonymous class that a ctor will
2068                      be generated for the anonymous class, with the
2069                      right arguments. */
2070
2071                 }
2072 |       NEW_TK class_type OP_TK CP_TK
2073                 { create_anonymous_class ($1.location, $2); }
2074         class_body
2075                 {
2076                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2077                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2078
2079                   end_class_declaration (1);
2080
2081                   /* Now we can craft the new expression. The
2082                      statement doesn't need to be remember so that a
2083                      constructor can be generated, since its signature
2084                      is already known. */
2085                   $$ = build_new_invocation (id, NULL_TREE);
2086                 }
2087 ;
2088
2089 something_dot_new:              /* Added, not part of the specs. */
2090         name DOT_TK NEW_TK
2091                 { $$ = $1; }
2092 |       primary DOT_TK NEW_TK
2093                 { $$ = $1; }
2094 ;
2095
2096 argument_list:
2097         expression
2098                 {
2099                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2100                   ctxp->formal_parameter_number = 1;
2101                 }
2102 |       argument_list C_TK expression
2103                 {
2104                   ctxp->formal_parameter_number += 1;
2105                   $$ = tree_cons (NULL_TREE, $3, $1);
2106                 }
2107 |       argument_list C_TK error
2108                 {yyerror ("Missing term"); RECOVER;}
2109 ;
2110
2111 array_creation_expression:
2112         NEW_TK primitive_type dim_exprs
2113                 { $$ = build_newarray_node ($2, $3, 0); }
2114 |       NEW_TK class_or_interface_type dim_exprs
2115                 { $$ = build_newarray_node ($2, $3, 0); }
2116 |       NEW_TK primitive_type dim_exprs dims
2117                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2118 |       NEW_TK class_or_interface_type dim_exprs dims
2119                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2120         /* Added, JDK1.1 anonymous array. Initial documentation rule
2121            modified */
2122 |       NEW_TK class_or_interface_type dims array_initializer
2123                 {
2124                   char *sig;
2125                   int osb = pop_current_osb (ctxp);
2126                   while (osb--)
2127                     obstack_grow (&temporary_obstack, "[]", 2);
2128                   obstack_1grow (&temporary_obstack, '\0');
2129                   sig = obstack_finish (&temporary_obstack);
2130                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2131                               $2, get_identifier (sig), $4);
2132                 }
2133 |       NEW_TK primitive_type dims array_initializer
2134                 {
2135                   int osb = pop_current_osb (ctxp);
2136                   tree type = $2;
2137                   while (osb--)
2138                     type = build_java_array_type (type, -1);
2139                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2140                               build_pointer_type (type), NULL_TREE, $4);
2141                 }
2142 |       NEW_TK error CSB_TK
2143                 {yyerror ("'[' expected"); DRECOVER ("]");}
2144 |       NEW_TK error OSB_TK
2145                 {yyerror ("']' expected"); RECOVER;}
2146 ;
2147
2148 dim_exprs:
2149         dim_expr
2150                 { $$ = build_tree_list (NULL_TREE, $1); }
2151 |       dim_exprs dim_expr
2152                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2153 ;
2154
2155 dim_expr:
2156         OSB_TK expression CSB_TK
2157                 {
2158                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2159                     {
2160                       $2 = build_wfl_node ($2);
2161                       TREE_TYPE ($2) = NULL_TREE;
2162                     }
2163                   EXPR_WFL_LINECOL ($2) = $1.location;
2164                   $$ = $2;
2165                 }
2166 |       OSB_TK expression error
2167                 {yyerror ("']' expected"); RECOVER;}
2168 |       OSB_TK error
2169                 {
2170                   yyerror ("Missing term");
2171                   yyerror ("']' expected");
2172                   RECOVER;
2173                 }
2174 ;
2175
2176 dims:
2177         OSB_TK CSB_TK
2178                 {
2179                   int allocate = 0;
2180                   /* If not initialized, allocate memory for the osb
2181                      numbers stack */
2182                   if (!ctxp->osb_limit)
2183                     {
2184                       allocate = ctxp->osb_limit = 32;
2185                       ctxp->osb_depth = -1;
2186                     }
2187                   /* If capacity overflown, reallocate a bigger chunk */
2188                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2189                     allocate = ctxp->osb_limit << 1;
2190
2191                   if (allocate)
2192                     {
2193                       allocate *= sizeof (int);
2194                       if (ctxp->osb_number)
2195                         ctxp->osb_number = xrealloc (ctxp->osb_number,
2196                                                      allocate);
2197                       else
2198                         ctxp->osb_number = xmalloc (allocate);
2199                     }
2200                   ctxp->osb_depth++;
2201                   CURRENT_OSB (ctxp) = 1;
2202                 }
2203 |       dims OSB_TK CSB_TK
2204                 { CURRENT_OSB (ctxp)++; }
2205 |       dims OSB_TK error
2206                 { yyerror ("']' expected"); RECOVER;}
2207 ;
2208
2209 field_access:
2210         primary DOT_TK identifier
2211                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2212                 /*  FIXME - REWRITE TO:
2213                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2214 |       SUPER_TK DOT_TK identifier
2215                 {
2216                   tree super_wfl = build_wfl_node (super_identifier_node);
2217                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
2218                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2219                 }
2220 |       SUPER_TK error
2221                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2222 ;
2223
2224 method_invocation:
2225         name OP_TK CP_TK
2226                 { $$ = build_method_invocation ($1, NULL_TREE); }
2227 |       name OP_TK argument_list CP_TK
2228                 { $$ = build_method_invocation ($1, $3); }
2229 |       primary DOT_TK identifier OP_TK CP_TK
2230                 {
2231                   if (TREE_CODE ($1) == THIS_EXPR)
2232                     $$ = build_this_super_qualified_invocation
2233                       (1, $3, NULL_TREE, 0, $2.location);
2234                   else
2235                     {
2236                       tree invok = build_method_invocation ($3, NULL_TREE);
2237                       $$ = make_qualified_primary ($1, invok, $2.location);
2238                     }
2239                 }
2240 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2241                 {
2242                   if (TREE_CODE ($1) == THIS_EXPR)
2243                     $$ = build_this_super_qualified_invocation
2244                       (1, $3, $5, 0, $2.location);
2245                   else
2246                     {
2247                       tree invok = build_method_invocation ($3, $5);
2248                       $$ = make_qualified_primary ($1, invok, $2.location);
2249                     }
2250                 }
2251 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2252                 {
2253                   $$ = build_this_super_qualified_invocation
2254                     (0, $3, NULL_TREE, $1.location, $2.location);
2255                 }
2256 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2257                 {
2258                   $$ = build_this_super_qualified_invocation
2259                     (0, $3, $5, $1.location, $2.location);
2260                 }
2261         /* Screws up thing. I let it here until I'm convinced it can
2262            be removed. FIXME
2263 |       primary DOT_TK error
2264                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2265 |       SUPER_TK DOT_TK error CP_TK
2266                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2267 |       SUPER_TK DOT_TK error DOT_TK
2268                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2269 ;
2270
2271 array_access:
2272         name OSB_TK expression CSB_TK
2273                 { $$ = build_array_ref ($2.location, $1, $3); }
2274 |       primary_no_new_array OSB_TK expression CSB_TK
2275                 { $$ = build_array_ref ($2.location, $1, $3); }
2276 |       name OSB_TK error
2277                 {
2278                   yyerror ("Missing term and ']' expected");
2279                   DRECOVER(array_access);
2280                 }
2281 |       name OSB_TK expression error
2282                 {
2283                   yyerror ("']' expected");
2284                   DRECOVER(array_access);
2285                 }
2286 |       primary_no_new_array OSB_TK error
2287                 {
2288                   yyerror ("Missing term and ']' expected");
2289                   DRECOVER(array_access);
2290                 }
2291 |       primary_no_new_array OSB_TK expression error
2292                 {
2293                   yyerror ("']' expected");
2294                   DRECOVER(array_access);
2295                 }
2296 ;
2297
2298 postfix_expression:
2299         primary
2300 |       name
2301 |       post_increment_expression
2302 |       post_decrement_expression
2303 ;
2304
2305 post_increment_expression:
2306         postfix_expression INCR_TK
2307                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2308 ;
2309
2310 post_decrement_expression:
2311         postfix_expression DECR_TK
2312                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2313 ;
2314
2315 trap_overflow_corner_case:
2316         pre_increment_expression
2317 |       pre_decrement_expression
2318 |       PLUS_TK unary_expression
2319                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2320 |       unary_expression_not_plus_minus
2321 |       PLUS_TK error
2322                 {yyerror ("Missing term"); RECOVER}
2323 ;
2324
2325 unary_expression:
2326         trap_overflow_corner_case
2327                 {
2328                   error_if_numeric_overflow ($1);
2329                   $$ = $1;
2330                 }
2331 |       MINUS_TK trap_overflow_corner_case
2332                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2333 |       MINUS_TK error
2334                 {yyerror ("Missing term"); RECOVER}
2335 ;
2336
2337 pre_increment_expression:
2338         INCR_TK unary_expression
2339                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2340 |       INCR_TK error
2341                 {yyerror ("Missing term"); RECOVER}
2342 ;
2343
2344 pre_decrement_expression:
2345         DECR_TK unary_expression
2346                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2347 |       DECR_TK error
2348                 {yyerror ("Missing term"); RECOVER}
2349 ;
2350
2351 unary_expression_not_plus_minus:
2352         postfix_expression
2353 |       NOT_TK unary_expression
2354                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2355 |       NEG_TK unary_expression
2356                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2357 |       cast_expression
2358 |       NOT_TK error
2359                 {yyerror ("Missing term"); RECOVER}
2360 |       NEG_TK error
2361                 {yyerror ("Missing term"); RECOVER}
2362 ;
2363
2364 cast_expression:                /* Error handling here is potentially weak */
2365         OP_TK primitive_type dims CP_TK unary_expression
2366                 {
2367                   tree type = $2;
2368                   int osb = pop_current_osb (ctxp);
2369                   while (osb--)
2370                     type = build_java_array_type (type, -1);
2371                   $$ = build_cast ($1.location, type, $5);
2372                 }
2373 |       OP_TK primitive_type CP_TK unary_expression
2374                 { $$ = build_cast ($1.location, $2, $4); }
2375 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2376                 { $$ = build_cast ($1.location, $2, $4); }
2377 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2378                 {
2379                   const char *ptr;
2380                   int osb = pop_current_osb (ctxp);
2381                   obstack_grow (&temporary_obstack,
2382                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2383                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2384                   while (osb--)
2385                     obstack_grow (&temporary_obstack, "[]", 2);
2386                   obstack_1grow (&temporary_obstack, '\0');
2387                   ptr = obstack_finish (&temporary_obstack);
2388                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2389                   $$ = build_cast ($1.location, $2, $5);
2390                 }
2391 |       OP_TK primitive_type OSB_TK error
2392                 {yyerror ("']' expected, invalid type expression");}
2393 |       OP_TK error
2394                 {
2395                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2396                   RECOVER;
2397                 }
2398 |       OP_TK primitive_type dims CP_TK error
2399                 {yyerror ("Missing term"); RECOVER;}
2400 |       OP_TK primitive_type CP_TK error
2401                 {yyerror ("Missing term"); RECOVER;}
2402 |       OP_TK name dims CP_TK error
2403                 {yyerror ("Missing term"); RECOVER;}
2404 ;
2405
2406 multiplicative_expression:
2407         unary_expression
2408 |       multiplicative_expression MULT_TK unary_expression
2409                 {
2410                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2411                                     $2.location, $1, $3);
2412                 }
2413 |       multiplicative_expression DIV_TK unary_expression
2414                 {
2415                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2416                                     $1, $3);
2417                 }
2418 |       multiplicative_expression REM_TK unary_expression
2419                 {
2420                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2421                                     $1, $3);
2422                 }
2423 |       multiplicative_expression MULT_TK error
2424                 {yyerror ("Missing term"); RECOVER;}
2425 |       multiplicative_expression DIV_TK error
2426                 {yyerror ("Missing term"); RECOVER;}
2427 |       multiplicative_expression REM_TK error
2428                 {yyerror ("Missing term"); RECOVER;}
2429 ;
2430
2431 additive_expression:
2432         multiplicative_expression
2433 |       additive_expression PLUS_TK multiplicative_expression
2434                 {
2435                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2436                                     $1, $3);
2437                 }
2438 |       additive_expression MINUS_TK multiplicative_expression
2439                 {
2440                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2441                                     $1, $3);
2442                 }
2443 |       additive_expression PLUS_TK error
2444                 {yyerror ("Missing term"); RECOVER;}
2445 |       additive_expression MINUS_TK error
2446                 {yyerror ("Missing term"); RECOVER;}
2447 ;
2448
2449 shift_expression:
2450         additive_expression
2451 |       shift_expression LS_TK additive_expression
2452                 {
2453                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2454                                     $1, $3);
2455                 }
2456 |       shift_expression SRS_TK additive_expression
2457                 {
2458                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2459                                     $1, $3);
2460                 }
2461 |       shift_expression ZRS_TK additive_expression
2462                 {
2463                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2464                                     $1, $3);
2465                 }
2466 |       shift_expression LS_TK error
2467                 {yyerror ("Missing term"); RECOVER;}
2468 |       shift_expression SRS_TK error
2469                 {yyerror ("Missing term"); RECOVER;}
2470 |       shift_expression ZRS_TK error
2471                 {yyerror ("Missing term"); RECOVER;}
2472 ;
2473
2474 relational_expression:
2475         shift_expression
2476 |       relational_expression LT_TK shift_expression
2477                 {
2478                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2479                                     $1, $3);
2480                 }
2481 |       relational_expression GT_TK shift_expression
2482                 {
2483                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2484                                     $1, $3);
2485                 }
2486 |       relational_expression LTE_TK shift_expression
2487                 {
2488                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2489                                     $1, $3);
2490                 }
2491 |       relational_expression GTE_TK shift_expression
2492                 {
2493                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2494                                     $1, $3);
2495                 }
2496 |       relational_expression INSTANCEOF_TK reference_type
2497                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2498 |       relational_expression LT_TK error
2499                 {yyerror ("Missing term"); RECOVER;}
2500 |       relational_expression GT_TK error
2501                 {yyerror ("Missing term"); RECOVER;}
2502 |       relational_expression LTE_TK error
2503                 {yyerror ("Missing term"); RECOVER;}
2504 |       relational_expression GTE_TK error
2505                 {yyerror ("Missing term"); RECOVER;}
2506 |       relational_expression INSTANCEOF_TK error
2507                 {yyerror ("Invalid reference type"); RECOVER;}
2508 ;
2509
2510 equality_expression:
2511         relational_expression
2512 |       equality_expression EQ_TK relational_expression
2513                 {
2514                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2515                                     $1, $3);
2516                 }
2517 |       equality_expression NEQ_TK relational_expression
2518                 {
2519                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2520                                     $1, $3);
2521                 }
2522 |       equality_expression EQ_TK error
2523                 {yyerror ("Missing term"); RECOVER;}
2524 |       equality_expression NEQ_TK error
2525                 {yyerror ("Missing term"); RECOVER;}
2526 ;
2527
2528 and_expression:
2529         equality_expression
2530 |       and_expression AND_TK equality_expression
2531                 {
2532                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2533                                     $1, $3);
2534                 }
2535 |       and_expression AND_TK error
2536                 {yyerror ("Missing term"); RECOVER;}
2537 ;
2538
2539 exclusive_or_expression:
2540         and_expression
2541 |       exclusive_or_expression XOR_TK and_expression
2542                 {
2543                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2544                                     $1, $3);
2545                 }
2546 |       exclusive_or_expression XOR_TK error
2547                 {yyerror ("Missing term"); RECOVER;}
2548 ;
2549
2550 inclusive_or_expression:
2551         exclusive_or_expression
2552 |       inclusive_or_expression OR_TK exclusive_or_expression
2553                 {
2554                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2555                                     $1, $3);
2556                 }
2557 |       inclusive_or_expression OR_TK error
2558                 {yyerror ("Missing term"); RECOVER;}
2559 ;
2560
2561 conditional_and_expression:
2562         inclusive_or_expression
2563 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2564                 {
2565                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2566                                     $1, $3);
2567                 }
2568 |       conditional_and_expression BOOL_AND_TK error
2569                 {yyerror ("Missing term"); RECOVER;}
2570 ;
2571
2572 conditional_or_expression:
2573         conditional_and_expression
2574 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2575                 {
2576                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2577                                     $1, $3);
2578                 }
2579 |       conditional_or_expression BOOL_OR_TK error
2580                 {yyerror ("Missing term"); RECOVER;}
2581 ;
2582
2583 conditional_expression:         /* Error handling here is weak */
2584         conditional_or_expression
2585 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2586                 {
2587                   $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2588                   EXPR_WFL_LINECOL ($$) = $2.location;
2589                 }
2590 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2591                 {
2592                   YYERROR_NOW;
2593                   yyerror ("Missing term");
2594                   DRECOVER (1);
2595                 }
2596 |       conditional_or_expression REL_QM_TK error
2597                 {yyerror ("Missing term"); DRECOVER (2);}
2598 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2599                 {yyerror ("Missing term"); DRECOVER (3);}
2600 ;
2601
2602 assignment_expression:
2603         conditional_expression
2604 |       assignment
2605 ;
2606
2607 assignment:
2608         left_hand_side assignment_operator assignment_expression
2609                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2610 |       left_hand_side assignment_operator error
2611                 {
2612                   YYNOT_TWICE yyerror ("Missing term");
2613                   DRECOVER (assign);
2614                 }
2615 ;
2616
2617 left_hand_side:
2618         name
2619 |       field_access
2620 |       array_access
2621 ;
2622
2623 assignment_operator:
2624         ASSIGN_ANY_TK
2625 |       ASSIGN_TK
2626 ;
2627
2628 expression:
2629         assignment_expression
2630 ;
2631
2632 constant_expression:
2633         expression
2634 ;
2635
2636 %%
2637
2638 /* Helper function to retrieve an OSB count. Should be used when the
2639    `dims:' rule is being used.  */
2640
2641 static int
2642 pop_current_osb (struct parser_ctxt *ctxp)
2643 {
2644   int to_return;
2645
2646   if (ctxp->osb_depth < 0)
2647     abort ();
2648
2649   to_return = CURRENT_OSB (ctxp);
2650   ctxp->osb_depth--;
2651
2652   return to_return;
2653 }
2654
2655 \f
2656
2657 /* This section of the code deal with save/restoring parser contexts.
2658    Add mode documentation here. FIXME */
2659
2660 /* Helper function. Create a new parser context. With
2661    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2662    context is copied, otherwise, the new context is zeroed. The newly
2663    created context becomes the current one.  */
2664
2665 static void
2666 create_new_parser_context (int copy_from_previous)
2667 {
2668   struct parser_ctxt *new;
2669
2670   new = ggc_alloc (sizeof (struct parser_ctxt));
2671   if (copy_from_previous)
2672     {
2673       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2674       /* This flag, indicating the context saves global values,
2675          should only be set by java_parser_context_save_global.  */
2676       new->saved_data_ctx = 0;
2677     }
2678   else
2679     memset (new, 0, sizeof (struct parser_ctxt));
2680
2681   new->next = ctxp;
2682   ctxp = new;
2683 }
2684
2685 /* Create a new parser context and make it the current one. */
2686
2687 void
2688 java_push_parser_context (void)
2689 {
2690   create_new_parser_context (0);
2691 }
2692
2693 void
2694 java_pop_parser_context (int generate)
2695 {
2696   tree current;
2697   struct parser_ctxt *toFree, *next;
2698
2699   if (!ctxp)
2700     return;
2701
2702   toFree = ctxp;
2703   next = ctxp->next;
2704   if (next)
2705     {
2706       input_line = ctxp->lineno;
2707       current_class = ctxp->class_type;
2708     }
2709
2710   /* If the old and new lexers differ, then free the old one.  */
2711   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2712     java_destroy_lexer (ctxp->lexer);
2713
2714   /* Set the single import class file flag to 0 for the current list
2715      of imported things */
2716   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2717     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2718
2719   /* And restore those of the previous context */
2720   if ((ctxp = next))            /* Assignment is really meant here */
2721     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2722       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2723
2724   /* If we pushed a context to parse a class intended to be generated,
2725      we keep it so we can remember the class. What we could actually
2726      do is to just update a list of class names.  */
2727   if (generate)
2728     {
2729       toFree->next = ctxp_for_generation;
2730       ctxp_for_generation = toFree;
2731     }
2732 }
2733
2734 /* Create a parser context for the use of saving some global
2735    variables.  */
2736
2737 void
2738 java_parser_context_save_global (void)
2739 {
2740   if (!ctxp)
2741     {
2742       java_push_parser_context ();
2743       ctxp->saved_data_ctx = 1;
2744     }
2745
2746   /* If this context already stores data, create a new one suitable
2747      for data storage. */
2748   else if (ctxp->saved_data)
2749     {
2750       create_new_parser_context (1);
2751       ctxp->saved_data_ctx = 1;
2752     }
2753
2754   ctxp->lineno = input_line;
2755   ctxp->class_type = current_class;
2756   ctxp->filename = input_filename;
2757   ctxp->function_decl = current_function_decl;
2758   ctxp->saved_data = 1;
2759 }
2760
2761 /* Restore some global variables from the previous context. Make the
2762    previous context the current one.  */
2763
2764 void
2765 java_parser_context_restore_global (void)
2766 {
2767   input_line = ctxp->lineno;
2768   current_class = ctxp->class_type;
2769   input_filename = ctxp->filename;
2770   if (wfl_operator)
2771     {
2772       tree s;
2773       BUILD_FILENAME_IDENTIFIER_NODE (s, input_filename);
2774       EXPR_WFL_FILENAME_NODE (wfl_operator) = s;
2775     }
2776   current_function_decl = ctxp->function_decl;
2777   ctxp->saved_data = 0;
2778   if (ctxp->saved_data_ctx)
2779     java_pop_parser_context (0);
2780 }
2781
2782 /* Suspend vital data for the current class/function being parsed so
2783    that an other class can be parsed. Used to let local/anonymous
2784    classes be parsed.  */
2785
2786 static void
2787 java_parser_context_suspend (void)
2788 {
2789   /* This makes debugging through java_debug_context easier */
2790   static const char *const name = "<inner buffer context>";
2791
2792   /* Duplicate the previous context, use it to save the globals we're
2793      interested in */
2794   create_new_parser_context (1);
2795   ctxp->function_decl = current_function_decl;
2796   ctxp->class_type = current_class;
2797
2798   /* Then create a new context which inherits all data from the
2799      previous one. This will be the new current context  */
2800   create_new_parser_context (1);
2801
2802   /* Help debugging */
2803   ctxp->next->filename = name;
2804 }
2805
2806 /* Resume vital data for the current class/function being parsed so
2807    that an other class can be parsed. Used to let local/anonymous
2808    classes be parsed.  The trick is the data storing file position
2809    informations must be restored to their current value, so parsing
2810    can resume as if no context was ever saved. */
2811
2812 static void
2813 java_parser_context_resume (void)
2814 {
2815   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2816   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2817   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2818
2819   /* We need to inherit the list of classes to complete/generate */
2820   restored->classd_list = old->classd_list;
2821   restored->class_list = old->class_list;
2822
2823   /* Restore the current class and function from the saver */
2824   current_class = saver->class_type;
2825   current_function_decl = saver->function_decl;
2826
2827   /* Retrieve the restored context */
2828   ctxp = restored;
2829
2830   /* Re-installed the data for the parsing to carry on */
2831   memcpy (&ctxp->marker_begining, &old->marker_begining,
2832           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2833 }
2834
2835 /* Add a new anchor node to which all statement(s) initializing static
2836    and non static initialized upon declaration field(s) will be
2837    linked.  */
2838
2839 static void
2840 java_parser_context_push_initialized_field (void)
2841 {
2842   tree node;
2843
2844   node = build_tree_list (NULL_TREE, NULL_TREE);
2845   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2846   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2847
2848   node = build_tree_list (NULL_TREE, NULL_TREE);
2849   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2850   CPC_INITIALIZER_LIST (ctxp) = node;
2851
2852   node = build_tree_list (NULL_TREE, NULL_TREE);
2853   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2854   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2855 }
2856
2857 /* Pop the lists of initialized field. If this lists aren't empty,
2858    remember them so we can use it to create and populate the finit$
2859    or <clinit> functions. */
2860
2861 static void
2862 java_parser_context_pop_initialized_field (void)
2863 {
2864   tree stmts;
2865   tree class_type = TREE_TYPE (GET_CPC ());
2866
2867   if (CPC_INITIALIZER_LIST (ctxp))
2868     {
2869       stmts = CPC_INITIALIZER_STMT (ctxp);
2870       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2871       if (stmts && !java_error_count)
2872         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2873     }
2874
2875   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2876     {
2877       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2878       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2879         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2880       /* Keep initialization in order to enforce 8.5 */
2881       if (stmts && !java_error_count)
2882         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2883     }
2884
2885   /* JDK 1.1 instance initializers */
2886   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2887     {
2888       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2889       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2890         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2891       if (stmts && !java_error_count)
2892         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2893     }
2894 }
2895
2896 static tree
2897 reorder_static_initialized (tree list)
2898 {
2899   /* We have to keep things in order. The alias initializer have to
2900      come first, then the initialized regular field, in reverse to
2901      keep them in lexical order. */
2902   tree marker, previous = NULL_TREE;
2903   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2904     if (TREE_CODE (marker) == TREE_LIST
2905         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2906       break;
2907
2908   /* No static initialized, the list is fine as is */
2909   if (!previous)
2910     list = TREE_CHAIN (marker);
2911
2912   /* No marker? reverse the whole list */
2913   else if (!marker)
2914     list = nreverse (list);
2915
2916   /* Otherwise, reverse what's after the marker and the new reordered
2917      sublist will replace the marker. */
2918   else
2919     {
2920       TREE_CHAIN (previous) = NULL_TREE;
2921       list = nreverse (list);
2922       list = chainon (TREE_CHAIN (marker), list);
2923     }
2924   return list;
2925 }
2926
2927 /* Helper functions to dump the parser context stack.  */
2928
2929 #define TAB_CONTEXT(C) \
2930   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2931
2932 static void
2933 java_debug_context_do (int tab)
2934 {
2935   struct parser_ctxt *copy = ctxp;
2936   while (copy)
2937     {
2938       TAB_CONTEXT (tab);
2939       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2940       TAB_CONTEXT (tab);
2941       fprintf (stderr, "filename: %s\n", copy->filename);
2942       TAB_CONTEXT (tab);
2943       fprintf (stderr, "lineno: %d\n", copy->lineno);
2944       TAB_CONTEXT (tab);
2945       fprintf (stderr, "package: %s\n",
2946                (copy->package ?
2947                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2948       TAB_CONTEXT (tab);
2949       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2950       TAB_CONTEXT (tab);
2951       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2952       copy = copy->next;
2953       tab += 2;
2954     }
2955 }
2956
2957 /* Dump the stacked up parser contexts. Intended to be called from a
2958    debugger.  */
2959
2960 void
2961 java_debug_context (void)
2962 {
2963   java_debug_context_do (0);
2964 }
2965
2966 \f
2967
2968 /* Flag for the error report routine to issue the error the first time
2969    it's called (overriding the default behavior which is to drop the
2970    first invocation and honor the second one, taking advantage of a
2971    richer context.  */
2972 static int force_error = 0;
2973
2974 /* Reporting an constructor invocation error.  */
2975 static void
2976 parse_ctor_invocation_error (void)
2977 {
2978   if (DECL_CONSTRUCTOR_P (current_function_decl))
2979     yyerror ("Constructor invocation must be first thing in a constructor");
2980   else
2981     yyerror ("Only constructors can invoke constructors");
2982 }
2983
2984 /* Reporting JDK1.1 features not implemented.  */
2985
2986 static tree
2987 parse_jdk1_1_error (const char *msg)
2988 {
2989   sorry (": `%s' JDK1.1(TM) feature", msg);
2990   java_error_count++;
2991   return empty_stmt_node;
2992 }
2993
2994 static int do_warning = 0;
2995
2996 void
2997 yyerror (const char *msg)
2998 {
2999   static java_lc elc;
3000   static int  prev_lineno;
3001   static const char *prev_msg;
3002
3003   int save_lineno;
3004   char *remainder, *code_from_source;
3005
3006   if (!force_error && prev_lineno == input_line)
3007     return;
3008
3009   /* Save current error location but report latter, when the context is
3010      richer.  */
3011   if (ctxp->java_error_flag == 0)
3012     {
3013       ctxp->java_error_flag = 1;
3014       elc = ctxp->elc;
3015       /* Do something to use the previous line if we're reaching the
3016          end of the file... */
3017 #ifdef VERBOSE_SKELETON
3018       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3019 #endif
3020       return;
3021     }
3022
3023   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3024   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3025     return;
3026
3027   ctxp->java_error_flag = 0;
3028   if (do_warning)
3029     java_warning_count++;
3030   else
3031     java_error_count++;
3032
3033   if (elc.col == 0 && msg && msg[1] == ';')
3034     {
3035       elc.col  = ctxp->p_line->char_col-1;
3036       elc.line = ctxp->p_line->lineno;
3037     }
3038
3039   save_lineno = input_line;
3040   prev_lineno = input_line = elc.line;
3041   prev_msg = msg;
3042
3043   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3044   obstack_grow0 (&temporary_obstack,
3045                  code_from_source, strlen (code_from_source));
3046   remainder = obstack_finish (&temporary_obstack);
3047   if (do_warning)
3048     warning ("%s.\n%s", msg, remainder);
3049   else
3050     error ("%s.\n%s", msg, remainder);
3051
3052   /* This allow us to cheaply avoid an extra 'Invalid expression
3053      statement' error report when errors have been already reported on
3054      the same line. This occurs when we report an error but don't have
3055      a synchronization point other than ';', which
3056      expression_statement is the only one to take care of.  */
3057   ctxp->prevent_ese = input_line = save_lineno;
3058 }
3059
3060 static void
3061 issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
3062 {
3063   const char *saved, *saved_input_filename;
3064   char buffer [4096];
3065   vsprintf (buffer, msg, ap);
3066   force_error = 1;
3067
3068   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3069   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3070                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3071
3072   /* We have a CL, that's a good reason for using it if it contains data */
3073   saved = ctxp->filename;
3074   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3075     ctxp->filename = EXPR_WFL_FILENAME (cl);
3076   saved_input_filename = input_filename;
3077   input_filename = ctxp->filename;
3078   java_error (NULL);
3079   java_error (buffer);
3080   ctxp->filename = saved;
3081   input_filename = saved_input_filename;
3082   force_error = 0;
3083 }
3084
3085 /* Issue an error message at a current source line CL */
3086
3087 void
3088 parse_error_context (tree cl, const char *msg, ...)
3089 {
3090   va_list ap;
3091   va_start (ap, msg);
3092   issue_warning_error_from_context (cl, msg, ap);
3093   va_end (ap);
3094 }
3095
3096 /* Issue a warning at a current source line CL */
3097
3098 static void
3099 parse_warning_context (tree cl, const char *msg, ...)
3100 {
3101   va_list ap;
3102   va_start (ap, msg);
3103
3104   force_error = do_warning = 1;
3105   issue_warning_error_from_context (cl, msg, ap);
3106   do_warning = force_error = 0;
3107   va_end (ap);
3108 }
3109
3110 static tree
3111 find_expr_with_wfl (tree node)
3112 {
3113   while (node)
3114     {
3115       char code;
3116       tree to_return;
3117
3118       switch (TREE_CODE (node))
3119         {
3120         case BLOCK:
3121           node = BLOCK_EXPR_BODY (node);
3122           continue;
3123
3124         case COMPOUND_EXPR:
3125           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3126           if (to_return)
3127             return to_return;
3128           node = TREE_OPERAND (node, 1);
3129           continue;
3130
3131         case LOOP_EXPR:
3132           node = TREE_OPERAND (node, 0);
3133           continue;
3134
3135         case LABELED_BLOCK_EXPR:
3136           node = TREE_OPERAND (node, 1);
3137           continue;
3138
3139         default:
3140           code = TREE_CODE_CLASS (TREE_CODE (node));
3141           if (((code == '1') || (code == '2') || (code == 'e'))
3142               && EXPR_WFL_LINECOL (node))
3143             return node;
3144           return NULL_TREE;
3145         }
3146     }
3147   return NULL_TREE;
3148 }
3149
3150 /* Issue a missing return statement error. Uses METHOD to figure the
3151    last line of the method the error occurs in.  */
3152
3153 static void
3154 missing_return_error (tree method)
3155 {
3156   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3157   parse_error_context (wfl_operator, "Missing return statement");
3158 }
3159
3160 /* Issue an unreachable statement error. From NODE, find the next
3161    statement to report appropriately.  */
3162 static void
3163 unreachable_stmt_error (tree node)
3164 {
3165   /* Browse node to find the next expression node that has a WFL. Use
3166      the location to report the error */
3167   if (TREE_CODE (node) == COMPOUND_EXPR)
3168     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3169   else
3170     node = find_expr_with_wfl (node);
3171
3172   if (node)
3173     {
3174       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3175       parse_error_context (wfl_operator, "Unreachable statement");
3176     }
3177   else
3178     abort ();
3179 }
3180
3181 static int
3182 not_accessible_field_error (tree wfl, tree decl)
3183 {
3184   parse_error_context
3185     (wfl, "Can't access %s field `%s.%s' from `%s'",
3186      accessibility_string (get_access_flags_from_decl (decl)),
3187      GET_TYPE_NAME (DECL_CONTEXT (decl)),
3188      IDENTIFIER_POINTER (DECL_NAME (decl)),
3189      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3190   return 1;
3191 }
3192
3193 int
3194 java_report_errors (void)
3195 {
3196   if (java_error_count)
3197     fprintf (stderr, "%d error%s",
3198              java_error_count, (java_error_count == 1 ? "" : "s"));
3199   if (java_warning_count)
3200     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3201              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3202   if (java_error_count || java_warning_count)
3203     putc ('\n', stderr);
3204   return java_error_count;
3205 }
3206
3207 static char *
3208 java_accstring_lookup (int flags)
3209 {
3210   static char buffer [80];
3211 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3212
3213   /* Access modifier looked-up first for easier report on forbidden
3214      access. */
3215   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3216   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3217   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3218   if (flags & ACC_STATIC) COPY_RETURN ("static");
3219   if (flags & ACC_FINAL) COPY_RETURN ("final");
3220   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3221   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3222   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3223   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3224   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3225   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3226
3227   buffer [0] = '\0';
3228   return buffer;
3229 #undef COPY_RETURN
3230 }
3231
3232 /* Returns a string denoting the accessibility of a class or a member as
3233    indicated by FLAGS.  We need a separate function from
3234    java_accstring_lookup, as the latter can return spurious "static", etc.
3235    if package-private access is defined (in which case none of the
3236    relevant access control bits in FLAGS is set).  */
3237
3238 static const char *
3239 accessibility_string (int flags)
3240 {
3241   if (flags & ACC_PRIVATE) return "private";
3242   if (flags & ACC_PROTECTED) return "protected";
3243   if (flags & ACC_PUBLIC) return "public";
3244
3245   return "package-private";
3246 }
3247
3248 /* Issuing error messages upon redefinition of classes, interfaces or
3249    variables. */
3250
3251 static void
3252 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3253 {
3254   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3255                        context, IDENTIFIER_POINTER (id),
3256                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3257   /* Here we should point out where its redefined. It's a unicode. FIXME */
3258 }
3259
3260 static void
3261 variable_redefinition_error (tree context, tree name, tree type, int line)
3262 {
3263   const char *type_name;
3264
3265   /* Figure a proper name for type. We might haven't resolved it */
3266   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3267     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3268   else
3269     type_name = lang_printable_name (type, 0);
3270
3271   parse_error_context (context,
3272                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3273                        IDENTIFIER_POINTER (name),
3274                        type_name, IDENTIFIER_POINTER (name), line);
3275 }
3276
3277 /* If ANAME is terminated with `[]', it indicates an array. This
3278    function returns the number of `[]' found and if this number is
3279    greater than zero, it extracts the array type name and places it in
3280    the node pointed to by TRIMMED unless TRIMMED is null.  */
3281
3282 static int
3283 build_type_name_from_array_name (tree aname, tree *trimmed)
3284 {
3285   const char *name = IDENTIFIER_POINTER (aname);
3286   int len = IDENTIFIER_LENGTH (aname);
3287   int array_dims;
3288
3289   STRING_STRIP_BRACKETS (name, len, array_dims);
3290
3291   if (array_dims && trimmed)
3292     *trimmed = get_identifier_with_length (name, len);
3293
3294   return array_dims;
3295 }
3296
3297 static tree
3298 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3299 {
3300   int more_dims = 0;
3301
3302   /* Eventually get more dims */
3303   more_dims = build_type_name_from_array_name (name, &name);
3304
3305   /* If we have, then craft a new type for this variable */
3306   if (more_dims)
3307     {
3308       tree save = type;
3309
3310       /* If we have a pointer, use its type */
3311       if (TREE_CODE (type) == POINTER_TYPE)
3312         type = TREE_TYPE (type);
3313
3314       /* Building the first dimension of a primitive type uses this
3315          function */
3316       if (JPRIMITIVE_TYPE_P (type))
3317         {
3318           type = build_java_array_type (type, -1);
3319           more_dims--;
3320         }
3321       /* Otherwise, if we have a WFL for this type, use it (the type
3322          is already an array on an unresolved type, and we just keep
3323          on adding dimensions) */
3324       else if (type_wfl)
3325         {
3326           type = type_wfl;
3327           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3328                                                         NULL);
3329         }
3330
3331       /* Add all the dimensions */
3332       while (more_dims--)
3333         type = build_unresolved_array_type (type);
3334
3335       /* The type may have been incomplete in the first place */
3336       if (type_wfl)
3337         type = obtain_incomplete_type (type);
3338     }
3339
3340   if (ret_name)
3341     *ret_name = name;
3342   return type;
3343 }
3344
3345 /* Build something that the type identifier resolver will identify as
3346    being an array to an unresolved type. TYPE_WFL is a WFL on a
3347    identifier. */
3348
3349 static tree
3350 build_unresolved_array_type (tree type_or_wfl)
3351 {
3352   const char *ptr;
3353   tree wfl;
3354
3355   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3356      just create a array type */
3357   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3358     return build_java_array_type (type_or_wfl, -1);
3359
3360   obstack_grow (&temporary_obstack,
3361                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3362                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3363   obstack_grow0 (&temporary_obstack, "[]", 2);
3364   ptr = obstack_finish (&temporary_obstack);
3365   wfl = build_expr_wfl (get_identifier (ptr),
3366                         EXPR_WFL_FILENAME (type_or_wfl),
3367                         EXPR_WFL_LINENO (type_or_wfl),
3368                         EXPR_WFL_COLNO (type_or_wfl));
3369   /* Re-install the existing qualifications so that the type can be
3370      resolved properly. */
3371   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3372   return wfl;
3373 }
3374
3375 static void
3376 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3377 {
3378   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3379     parse_error_context (wfl, "Interface `%s' repeated",
3380                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3381 }
3382
3383 /* Bulk of common class/interface checks. Return 1 if an error was
3384    encountered. TAG is 0 for a class, 1 for an interface.  */
3385
3386 static int
3387 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3388                                 tree qualified_name, tree decl, tree cl)
3389 {
3390   tree node;
3391   int sca = 0;                  /* Static class allowed */
3392   int icaf = 0;                 /* Inner class allowed flags */
3393   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3394
3395   if (!quiet_flag)
3396     fprintf (stderr, " %s%s %s",
3397              (CPC_INNER_P () ? "inner" : ""),
3398              (is_interface ? "interface" : "class"),
3399              IDENTIFIER_POINTER (qualified_name));
3400
3401   /* Scope of an interface/class type name:
3402        - Can't be imported by a single type import
3403        - Can't already exists in the package */
3404   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3405       && (node = find_name_in_single_imports (raw_name))
3406       && !CPC_INNER_P ())
3407     {
3408       parse_error_context
3409         (cl, "%s name `%s' clashes with imported type `%s'",
3410          (is_interface ? "Interface" : "Class"),
3411          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3412       return 1;
3413     }
3414   if (decl && CLASS_COMPLETE_P (decl))
3415     {
3416       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3417                                    qualified_name, decl, cl);
3418       return 1;
3419     }
3420
3421   if (check_inner_class_redefinition (raw_name, cl))
3422     return 1;
3423
3424   /* If public, file name should match class/interface name, except
3425      when dealing with an inner class */
3426   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3427     {
3428       const char *f;
3429
3430       for (f = &input_filename [strlen (input_filename)];
3431            f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3432            f--)
3433         ;
3434       if (IS_DIR_SEPARATOR (f[0]))
3435         f++;
3436       if (strncmp (IDENTIFIER_POINTER (raw_name),
3437                    f , IDENTIFIER_LENGTH (raw_name)) ||
3438           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3439         parse_error_context
3440           (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3441                              (is_interface ? "interface" : "class"),
3442                              IDENTIFIER_POINTER (qualified_name),
3443                              IDENTIFIER_POINTER (raw_name));
3444     }
3445
3446   /* Static classes can be declared only in top level classes. Note:
3447      once static, a inner class is a top level class. */
3448   if (flags & ACC_STATIC)
3449     {
3450       /* Catch the specific error of declaring an class inner class
3451          with no toplevel enclosing class. Prevent check_modifiers from
3452          complaining a second time */
3453       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3454         {
3455           parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3456                                IDENTIFIER_POINTER (qualified_name));
3457           sca = ACC_STATIC;
3458         }
3459       /* Else, in the context of a top-level class declaration, let
3460          `check_modifiers' do its job, otherwise, give it a go */
3461       else
3462         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3463     }
3464
3465   /* Inner classes can be declared private or protected
3466      within their enclosing classes. */
3467   if (CPC_INNER_P ())
3468     {
3469       /* A class which is local to a block can't be public, private,
3470          protected or static. But it is created final, so allow this
3471          one. */
3472       if (current_function_decl)
3473         icaf = sca = uaaf = ACC_FINAL;
3474       else
3475         {
3476           check_modifiers_consistency (flags);
3477           icaf = ACC_PROTECTED;
3478           if (! CLASS_INTERFACE (GET_CPC ()))
3479             icaf |= ACC_PRIVATE;
3480         }
3481     }
3482
3483   if (is_interface)
3484     {
3485       if (CPC_INNER_P ())
3486         uaaf = INTERFACE_INNER_MODIFIERS;
3487       else
3488         uaaf = INTERFACE_MODIFIERS;
3489
3490       check_modifiers ("Illegal modifier `%s' for interface declaration",
3491                        flags, uaaf);
3492     }
3493   else
3494     check_modifiers ((current_function_decl ?
3495                       "Illegal modifier `%s' for local class declaration" :
3496                       "Illegal modifier `%s' for class declaration"),
3497                      flags, uaaf|sca|icaf);
3498   return 0;
3499 }
3500
3501 /* Construct a nested class name.  If the final component starts with
3502    a digit, return true.  Otherwise return false.  */
3503 static int
3504 make_nested_class_name (tree cpc_list)
3505 {
3506   tree name;
3507
3508   if (!cpc_list)
3509     return 0;
3510
3511   make_nested_class_name (TREE_CHAIN (cpc_list));
3512
3513   /* Pick the qualified name when dealing with the first upmost
3514      enclosing class */
3515   name = (TREE_CHAIN (cpc_list)
3516           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3517   obstack_grow (&temporary_obstack,
3518                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3519   obstack_1grow (&temporary_obstack, '$');
3520
3521   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3522 }
3523
3524 /* Can't redefine a class already defined in an earlier scope. */
3525
3526 static int
3527 check_inner_class_redefinition (tree raw_name, tree cl)
3528 {
3529   tree scope_list;
3530
3531   for (scope_list = GET_CPC_LIST (); scope_list;
3532        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3533     if (raw_name == GET_CPC_UN_NODE (scope_list))
3534       {
3535         parse_error_context
3536           (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",
3537            IDENTIFIER_POINTER (raw_name));
3538         return 1;
3539       }
3540   return 0;
3541 }
3542
3543 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3544    we remember ENCLOSING and SUPER.  */
3545
3546 static tree
3547 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3548                      tree *super, tree class_type)
3549 {
3550   tree local_enclosing = *enclosing;
3551   tree local_super = NULL_TREE;
3552
3553   while (local_enclosing)
3554     {
3555       tree intermediate, decl;
3556
3557       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3558         local_enclosing;
3559
3560       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3561         return decl;
3562
3563       intermediate = local_enclosing;
3564       /* Explore enclosing contexts. */
3565       while (INNER_CLASS_DECL_P (intermediate))
3566         {
3567           intermediate = DECL_CONTEXT (intermediate);
3568           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3569             return decl;
3570         }
3571
3572       /* Now go to the upper classes, bail out if necessary.  We will
3573          analyze the returned SUPER and act accordingly (see
3574          do_resolve_class).  */
3575       if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3576           || TREE_TYPE (local_enclosing) == void_type_node)
3577         {
3578           parse_error_context (cl, "Qualifier must be a reference");
3579           local_enclosing = NULL_TREE;
3580           break;
3581         }
3582       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3583       if (!local_super || local_super == object_type_node)
3584         break;
3585
3586       if (TREE_CODE (local_super) == POINTER_TYPE)
3587         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3588       else
3589         local_super = TYPE_NAME (local_super);
3590
3591       /* We may not have checked for circular inheritance yet, so do so
3592          here to prevent an infinite loop. */
3593       if (htab_find (circularity_hash, local_super) != NULL)
3594         {
3595           if (!cl)
3596             cl = lookup_cl (local_enclosing);
3597
3598           parse_error_context
3599             (cl, "Cyclic inheritance involving %s",
3600              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3601           local_enclosing = NULL_TREE;
3602         }
3603       else
3604         local_enclosing = local_super;
3605     }
3606
3607   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3608   *super = local_super;
3609   *enclosing = local_enclosing;
3610
3611   return NULL_TREE;
3612 }
3613
3614 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3615    qualified. */
3616
3617 static tree
3618 find_as_inner_class (tree enclosing, tree name, tree cl)
3619 {
3620   tree qual, to_return;
3621   if (!enclosing)
3622     return NULL_TREE;
3623
3624   name = TYPE_NAME (name);
3625
3626   /* First search: within the scope of `enclosing', search for name */
3627   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3628     qual = EXPR_WFL_QUALIFICATION (cl);
3629   else if (cl)
3630     qual = build_tree_list (cl, NULL_TREE);
3631   else
3632     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3633
3634   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3635     return to_return;
3636
3637   /* We're dealing with a qualified name. Try to resolve thing until
3638      we get something that is an enclosing class. */
3639   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3640     {
3641       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3642
3643       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3644            qual = TREE_CHAIN (qual))
3645         {
3646           acc = merge_qualified_name (acc,
3647                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3648           BUILD_PTR_FROM_NAME (ptr, acc);
3649           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3650         }
3651
3652       /* A NULL qual and a decl means that the search ended
3653          successfully?!? We have to do something then. FIXME */
3654
3655       if (decl)
3656         enclosing = decl;
3657       else
3658         qual = EXPR_WFL_QUALIFICATION (cl);
3659     }
3660   /* Otherwise, create a qual for the other part of the resolution. */
3661   else
3662     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3663
3664   return find_as_inner_class_do (qual, enclosing);
3665 }
3666
3667 /* We go inside the list of sub classes and try to find a way
3668    through. */
3669
3670 static tree
3671 find_as_inner_class_do (tree qual, tree enclosing)
3672 {
3673   if (!qual)
3674     return NULL_TREE;
3675
3676   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3677     {
3678       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3679       tree next_enclosing = NULL_TREE;
3680       tree inner_list;
3681
3682       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3683            inner_list; inner_list = TREE_CHAIN (inner_list))
3684         {
3685           if (TREE_VALUE (inner_list) == name_to_match)
3686             {
3687               next_enclosing = TREE_PURPOSE (inner_list);
3688               break;
3689             }
3690         }
3691       enclosing = next_enclosing;
3692     }
3693
3694   return (!qual && enclosing ? enclosing : NULL_TREE);
3695 }
3696
3697 /* Reach all inner classes and tie their unqualified name to a
3698    DECL. */
3699
3700 static void
3701 set_nested_class_simple_name_value (tree outer, int set)
3702 {
3703   tree l;
3704
3705   for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
3706     IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
3707                                                 TREE_PURPOSE (l) : NULL_TREE);
3708 }
3709
3710 static void
3711 link_nested_class_to_enclosing (void)
3712 {
3713   if (GET_ENCLOSING_CPC ())
3714     {
3715       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3716       DECL_INNER_CLASS_LIST (enclosing) =
3717         tree_cons (GET_CPC (), GET_CPC_UN (),
3718                    DECL_INNER_CLASS_LIST (enclosing));
3719     }
3720 }
3721
3722 static tree
3723 maybe_make_nested_class_name (tree name)
3724 {
3725   tree id = NULL_TREE;
3726
3727   if (CPC_INNER_P ())
3728     {
3729       /* If we're in a function, we must append a number to create the
3730          nested class name.  However, we don't do this if the class we
3731          are constructing is anonymous, because in that case we'll
3732          already have a number as the class name.  */
3733       if (! make_nested_class_name (GET_CPC_LIST ())
3734           && current_function_decl != NULL_TREE
3735           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3736         {
3737           char buf[10];
3738           sprintf (buf, "%d", anonymous_class_counter);
3739           ++anonymous_class_counter;
3740           obstack_grow (&temporary_obstack, buf, strlen (buf));
3741           obstack_1grow (&temporary_obstack, '$');
3742         }
3743       obstack_grow0 (&temporary_obstack,
3744                      IDENTIFIER_POINTER (name),
3745                      IDENTIFIER_LENGTH (name));
3746       id = get_identifier (obstack_finish (&temporary_obstack));
3747       if (ctxp->package)
3748         QUALIFIED_P (id) = 1;
3749     }
3750   return id;
3751 }
3752
3753 /* If DECL is NULL, create and push a new DECL, record the current
3754    line CL and do other maintenance things.  */
3755
3756 static tree
3757 maybe_create_class_interface_decl (tree decl, tree raw_name,
3758                                    tree qualified_name, tree cl)
3759 {
3760   if (!decl)
3761     decl = push_class (make_class (), qualified_name);
3762
3763   /* Take care of the file and line business */
3764   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3765   /* If we're emitting xrefs, store the line/col number information */
3766   if (flag_emit_xref)
3767     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3768   else
3769     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3770   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3771   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3772   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3773     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3774
3775   PUSH_CPC (decl, raw_name);
3776   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3777
3778   /* Link the declaration to the already seen ones */
3779   TREE_CHAIN (decl) = ctxp->class_list;
3780   ctxp->class_list = decl;
3781
3782   /* Create a new nodes in the global lists */
3783   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3784   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3785
3786   /* Install a new dependency list element */
3787   create_jdep_list (ctxp);
3788
3789   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3790                           IDENTIFIER_POINTER (qualified_name)));
3791   return decl;
3792 }
3793
3794 static void
3795 add_superinterfaces (tree decl, tree interface_list)
3796 {
3797   tree node;
3798   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3799      takes care of ensuring that:
3800        - This is an accessible interface type,
3801        - Circularity detection.
3802    parser_add_interface is then called. If present but not defined,
3803    the check operation is delayed until the super interface gets
3804    defined.  */
3805   for (node = interface_list; node; node = TREE_CHAIN (node))
3806     {
3807       tree current = TREE_PURPOSE (node);
3808       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3809       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3810         {
3811           if (!parser_check_super_interface (idecl, decl, current))
3812             parser_add_interface (decl, idecl, current);
3813         }
3814       else
3815         register_incomplete_type (JDEP_INTERFACE,
3816                                   current, decl, NULL_TREE);
3817     }
3818 }
3819
3820 /* Create an interface in pass1 and return its decl. Return the
3821    interface's decl in pass 2.  */
3822
3823 static tree
3824 create_interface (int flags, tree id, tree super)
3825 {
3826   tree raw_name = EXPR_WFL_NODE (id);
3827   tree q_name = parser_qualified_classname (raw_name);
3828   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3829
3830   /* Certain syntax errors are making SUPER be like ID. Avoid this
3831      case. */
3832   if (ctxp->class_err && id == super)
3833     super = NULL;
3834
3835   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3836
3837   /* Basic checks: scope, redefinition, modifiers */
3838   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3839     {
3840       PUSH_ERROR ();
3841       return NULL_TREE;
3842     }
3843
3844   /* Suspend the current parsing context if we're parsing an inner
3845      interface */
3846   if (CPC_INNER_P ())
3847     {
3848       java_parser_context_suspend ();
3849       /* Interface members are public. */
3850       if (CLASS_INTERFACE (GET_CPC ()))
3851         flags |= ACC_PUBLIC;
3852     }
3853
3854   /* Push a new context for (static) initialized upon declaration fields */
3855   java_parser_context_push_initialized_field ();
3856
3857   /* Interface modifiers check
3858        - public/abstract allowed (already done at that point)
3859        - abstract is obsolete (comes first, it's a warning, or should be)
3860        - Can't use twice the same (checked in the modifier rule) */
3861   if ((flags & ACC_ABSTRACT) && flag_redundant)
3862     parse_warning_context
3863       (MODIFIER_WFL (ABSTRACT_TK),
3864        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3865
3866   /* Create a new decl if DECL is NULL, otherwise fix it */
3867   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3868
3869   /* Set super info and mark the class a complete */
3870   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3871                   object_type_node, ctxp->interface_number);
3872   ctxp->interface_number = 0;
3873   CLASS_COMPLETE_P (decl) = 1;
3874   add_superinterfaces (decl, super);
3875
3876   /* Eventually sets the @deprecated tag flag */
3877   CHECK_DEPRECATED (decl);
3878
3879   return decl;
3880 }
3881
3882 /* Patch anonymous class CLASS, by either extending or implementing
3883    DEP.  */
3884
3885 static void
3886 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
3887 {
3888   tree class = TREE_TYPE (class_decl);
3889   tree type =  TREE_TYPE (type_decl);
3890   tree binfo = TYPE_BINFO (class);
3891
3892   /* If it's an interface, implement it */
3893   if (CLASS_INTERFACE (type_decl))
3894     {
3895       tree s_binfo;
3896       int length;
3897
3898       if (parser_check_super_interface (type_decl, class_decl, wfl))
3899         return;
3900
3901       s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3902       length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3903       TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3904       TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3905       /* And add the interface */
3906       parser_add_interface (class_decl, type_decl, wfl);
3907     }
3908   /* Otherwise, it's a type we want to extend */
3909   else
3910     {
3911       if (parser_check_super (type_decl, class_decl, wfl))
3912         return;
3913       BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3914     }
3915 }
3916
3917 static tree
3918 create_anonymous_class (int location, tree type_name)
3919 {
3920   char buffer [80];
3921   tree super = NULL_TREE, itf = NULL_TREE;
3922   tree id, type_decl, class;
3923
3924   /* The unqualified name of the anonymous class. It's just a number. */
3925   sprintf (buffer, "%d", anonymous_class_counter++);
3926   id = build_wfl_node (get_identifier (buffer));
3927   EXPR_WFL_LINECOL (id) = location;
3928
3929   /* We know about the type to extend/implement. We go ahead */
3930   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3931     {
3932       /* Create a class which either implements on extends the designated
3933          class. The class bears an inaccessible name. */
3934       if (CLASS_INTERFACE (type_decl))
3935         {
3936           /* It's OK to modify it here. It's been already used and
3937              shouldn't be reused */
3938           ctxp->interface_number = 1;
3939           /* Interfaces should presented as a list of WFLs */
3940           itf = build_tree_list (type_name, NULL_TREE);
3941         }
3942       else
3943         super = type_name;
3944     }
3945
3946   class = create_class (ACC_FINAL, id, super, itf);
3947
3948   /* We didn't know anything about the stuff. We register a dependence. */
3949   if (!type_decl)
3950     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3951
3952   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3953   return class;
3954 }
3955
3956 /* Create a class in pass1 and return its decl. Return class
3957    interface's decl in pass 2.  */
3958
3959 static tree
3960 create_class (int flags, tree id, tree super, tree interfaces)
3961 {
3962   tree raw_name = EXPR_WFL_NODE (id);
3963   tree class_id, decl;
3964   tree super_decl_type;
3965
3966   /* Certain syntax errors are making SUPER be like ID. Avoid this
3967      case. */
3968   if (ctxp->class_err && id == super)
3969     super = NULL;
3970
3971   class_id = parser_qualified_classname (raw_name);
3972   decl = IDENTIFIER_CLASS_VALUE (class_id);
3973   EXPR_WFL_NODE (id) = class_id;
3974
3975   /* Basic check: scope, redefinition, modifiers */
3976   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3977     {
3978       PUSH_ERROR ();
3979       return NULL_TREE;
3980     }
3981
3982   /* Suspend the current parsing context if we're parsing an inner
3983      class or an anonymous class. */
3984   if (CPC_INNER_P ())
3985     {
3986       java_parser_context_suspend ();
3987       /* Interface members are public. */
3988       if (CLASS_INTERFACE (GET_CPC ()))
3989         flags |= ACC_PUBLIC;
3990     }
3991
3992   /* Push a new context for (static) initialized upon declaration fields */
3993   java_parser_context_push_initialized_field ();
3994
3995   /* Class modifier check:
3996        - Allowed modifier (already done at that point)
3997        - abstract AND final forbidden
3998        - Public classes defined in the correct file */
3999   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
4000     parse_error_context
4001       (id, "Class `%s' can't be declared both abstract and final",
4002        IDENTIFIER_POINTER (raw_name));
4003
4004   /* Create a new decl if DECL is NULL, otherwise fix it */
4005   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
4006
4007   /* If SUPER exists, use it, otherwise use Object */
4008   if (super)
4009     {
4010       /* Can't extend java.lang.Object */
4011       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
4012         {
4013           parse_error_context (id, "Can't extend `java.lang.Object'");
4014           return NULL_TREE;
4015         }
4016
4017       super_decl_type =
4018         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4019     }
4020   else if (TREE_TYPE (decl) != object_type_node)
4021     super_decl_type = object_type_node;
4022   /* We're defining java.lang.Object */
4023   else
4024     super_decl_type = NULL_TREE;
4025
4026   /* A class nested in an interface is implicitly static. */
4027   if (INNER_CLASS_DECL_P (decl)
4028       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4029     {
4030       flags |= ACC_STATIC;
4031     }
4032
4033   /* Set super info and mark the class as complete. */
4034   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4035                   ctxp->interface_number);
4036   ctxp->interface_number = 0;
4037   CLASS_COMPLETE_P (decl) = 1;
4038   add_superinterfaces (decl, interfaces);
4039
4040   /* TYPE_VFIELD' is a compiler-generated field used to point to
4041      virtual function tables.  In gcj, every class has a common base
4042      virtual function table in java.lang.object.  */
4043   TYPE_VFIELD (TREE_TYPE (decl)) = TYPE_VFIELD (object_type_node);
4044
4045   /* Add the private this$<n> field, Replicate final locals still in
4046      scope as private final fields mangled like val$<local_name>.
4047      This doesn't not occur for top level (static) inner classes. */
4048   if (PURE_INNER_CLASS_DECL_P (decl))
4049     add_inner_class_fields (decl, current_function_decl);
4050
4051   /* If doing xref, store the location at which the inherited class
4052      (if any) was seen. */
4053   if (flag_emit_xref && super)
4054     DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4055
4056   /* Eventually sets the @deprecated tag flag */
4057   CHECK_DEPRECATED (decl);
4058
4059   /* Reset the anonymous class counter when declaring non inner classes */
4060   if (!INNER_CLASS_DECL_P (decl))
4061     anonymous_class_counter = 1;
4062
4063   return decl;
4064 }
4065
4066 /* End a class declaration: register the statements used to create
4067    finit$ and <clinit>, pop the current class and resume the prior
4068    parser context if necessary.  */
4069
4070 static void
4071 end_class_declaration (int resume)
4072 {
4073   /* If an error occurred, context weren't pushed and won't need to be
4074      popped by a resume. */
4075   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4076
4077   if (GET_CPC () != error_mark_node)
4078     dump_java_tree (TDI_class, GET_CPC ());
4079
4080   java_parser_context_pop_initialized_field ();
4081   POP_CPC ();
4082   if (resume && no_error_occurred)
4083     java_parser_context_resume ();
4084
4085   /* We're ending a class declaration, this is a good time to reset
4086      the interface cout. Note that might have been already done in
4087      create_interface, but if at that time an inner class was being
4088      dealt with, the interface count was reset in a context created
4089      for the sake of handling inner classes declaration. */
4090   ctxp->interface_number = 0;
4091 }
4092
4093 static void
4094 add_inner_class_fields (tree class_decl, tree fct_decl)
4095 {
4096   tree block, marker, f;
4097
4098   f = add_field (TREE_TYPE (class_decl),
4099                  build_current_thisn (TREE_TYPE (class_decl)),
4100                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4101                  ACC_PRIVATE);
4102   FIELD_THISN (f) = 1;
4103
4104   if (!fct_decl)
4105     return;
4106
4107   for (block = GET_CURRENT_BLOCK (fct_decl);
4108        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4109     {
4110       tree decl;
4111       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4112         {
4113           tree name, pname;
4114           tree wfl, init, list;
4115
4116           /* Avoid non final arguments. */
4117           if (!LOCAL_FINAL_P (decl))
4118             continue;
4119
4120           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4121           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4122           wfl = build_wfl_node (name);
4123           init = build_wfl_node (pname);
4124           /* Build an initialization for the field: it will be
4125              initialized by a parameter added to finit$, bearing a
4126              mangled name of the field itself (param$<n>.) The
4127              parameter is provided to finit$ by the constructor
4128              invoking it (hence the constructor will also feature a
4129              hidden parameter, set to the value of the outer context
4130              local at the time the inner class is created.)
4131
4132              Note: we take into account all possible locals that can
4133              be accessed by the inner class. It's actually not trivial
4134              to minimize these aliases down to the ones really
4135              used. One way to do that would be to expand all regular
4136              methods first, then finit$ to get a picture of what's
4137              used.  It works with the exception that we would have to
4138              go back on all constructor invoked in regular methods to
4139              have their invocation reworked (to include the right amount
4140              of alias initializer parameters.)
4141
4142              The only real way around, I think, is a first pass to
4143              identify locals really used in the inner class. We leave
4144              the flag FIELD_LOCAL_ALIAS_USED around for that future
4145              use.
4146
4147              On the other hand, it only affect local inner classes,
4148              whose constructors (and finit$ call) will be featuring
4149              unnecessary arguments. It's easy for a developer to keep
4150              this number of parameter down by using the `final'
4151              keyword only when necessary. For the time being, we can
4152              issue a warning on unnecessary finals. FIXME */
4153           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4154                                    wfl, init);
4155
4156           /* Register the field. The TREE_LIST holding the part
4157              initialized/initializer will be marked ARG_FINAL_P so
4158              that the created field can be marked
4159              FIELD_LOCAL_ALIAS. */
4160           list = build_tree_list (wfl, init);
4161           ARG_FINAL_P (list) = 1;
4162           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4163         }
4164     }
4165
4166   if (!CPC_INITIALIZER_STMT (ctxp))
4167     return;
4168
4169   /* If we ever registered an alias field, insert and marker to
4170      remember where the list ends. The second part of the list (the one
4171      featuring initialized fields) so it can be later reversed to
4172      enforce 8.5. The marker will be removed during that operation. */
4173   marker = build_tree_list (NULL_TREE, NULL_TREE);
4174   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4175   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4176 }
4177
4178 /* Can't use lookup_field () since we don't want to load the class and
4179    can't set the CLASS_LOADED_P flag */
4180
4181 static tree
4182 find_field (tree class, tree name)
4183 {
4184   tree decl;
4185   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4186     {
4187       if (DECL_NAME (decl) == name)
4188         return decl;
4189     }
4190   return NULL_TREE;
4191 }
4192
4193 /* Wrap around lookup_field that doesn't potentially upset the value
4194    of CLASS */
4195
4196 static tree
4197 lookup_field_wrapper (tree class, tree name)
4198 {
4199   tree type = class;
4200   tree decl = NULL_TREE;
4201   java_parser_context_save_global ();
4202
4203   /* Last chance: if we're within the context of an inner class, we
4204      might be trying to access a local variable defined in an outer
4205      context. We try to look for it now. */
4206   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4207     {
4208       tree new_name;
4209       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4210       decl = lookup_field (&type, new_name);
4211       if (decl && decl != error_mark_node)
4212         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4213     }
4214   if (!decl || decl == error_mark_node)
4215     {
4216       type = class;
4217       decl = lookup_field (&type, name);
4218     }
4219
4220   /* If the field still hasn't been found, try the next enclosing context. */
4221   if (!decl && INNER_CLASS_TYPE_P (class))
4222     {
4223       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4224       decl = lookup_field_wrapper (outer_type, name);
4225     }
4226
4227   java_parser_context_restore_global ();
4228   return decl == error_mark_node ? NULL : decl;
4229 }
4230
4231 /* Find duplicate field within the same class declarations and report
4232    the error. Returns 1 if a duplicated field was found, 0
4233    otherwise.  */
4234
4235 static int
4236 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4237 {
4238   /* This might be modified to work with method decl as well */
4239   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4240   if (decl)
4241     {
4242       char *t1 = xstrdup (purify_type_name
4243                          ((TREE_CODE (new_type) == POINTER_TYPE
4244                            && TREE_TYPE (new_type) == NULL_TREE) ?
4245                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4246                           lang_printable_name (new_type, 1)));
4247       /* The type may not have been completed by the time we report
4248          the error */
4249       char *t2 = xstrdup (purify_type_name
4250                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4251                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4252                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4253                           lang_printable_name (TREE_TYPE (decl), 1)));
4254       parse_error_context
4255         (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4256          t1, IDENTIFIER_POINTER (new_field_name),
4257          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4258          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4259       free (t1);
4260       free (t2);
4261       return 1;
4262     }
4263   return 0;
4264 }
4265
4266 /* Field registration routine. If TYPE doesn't exist, field
4267    declarations are linked to the undefined TYPE dependency list, to
4268    be later resolved in java_complete_class () */
4269
4270 static void
4271 register_fields (int flags, tree type, tree variable_list)
4272 {
4273   tree current, saved_type;
4274   tree class_type = NULL_TREE;
4275   int saved_lineno = input_line;
4276   int must_chain = 0;
4277   tree wfl = NULL_TREE;
4278
4279   if (GET_CPC ())
4280     class_type = TREE_TYPE (GET_CPC ());
4281
4282   if (!class_type || class_type == error_mark_node)
4283     return;
4284
4285   /* If we're adding fields to interfaces, those fields are public,
4286      static, final */
4287   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4288     {
4289       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4290                                  flags, ACC_PUBLIC, "interface field(s)");
4291       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4292                                  flags, ACC_STATIC, "interface field(s)");
4293       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4294                                  flags, ACC_FINAL, "interface field(s)");
4295       check_modifiers ("Illegal interface member modifier `%s'", flags,
4296                        INTERFACE_FIELD_MODIFIERS);
4297       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4298     }
4299
4300   /* Obtain a suitable type for resolution, if necessary */
4301   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4302
4303   /* If TYPE is fully resolved and we don't have a reference, make one */
4304   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4305
4306   for (current = variable_list, saved_type = type; current;
4307        current = TREE_CHAIN (current), type = saved_type)
4308     {
4309       tree real_type;
4310       tree field_decl;
4311       tree cl = TREE_PURPOSE (current);
4312       tree init = TREE_VALUE (current);
4313       tree current_name = EXPR_WFL_NODE (cl);
4314
4315       /* Can't declare non-final static fields in inner classes */
4316       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4317           && !(flags & ACC_FINAL))
4318         parse_error_context
4319           (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4320            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4321            lang_printable_name (class_type, 0));
4322
4323       /* Process NAME, as it may specify extra dimension(s) for it */
4324       type = build_array_from_name (type, wfl, current_name, &current_name);
4325
4326       /* Type adjustment. We may have just readjusted TYPE because
4327          the variable specified more dimensions. Make sure we have
4328          a reference if we can and don't have one already. Also
4329          change the name if we have an init. */
4330       if (type != saved_type)
4331         {
4332           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4333           if (init)
4334             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4335         }
4336
4337       real_type = GET_REAL_TYPE (type);
4338       /* Check for redeclarations */
4339       if (duplicate_declaration_error_p (current_name, real_type, cl))
4340         continue;
4341
4342       /* Set lineno to the line the field was found and create a
4343          declaration for it. Eventually sets the @deprecated tag flag. */
4344       if (flag_emit_xref)
4345         input_line = EXPR_WFL_LINECOL (cl);
4346       else
4347         input_line = EXPR_WFL_LINENO (cl);
4348       field_decl = add_field (class_type, current_name, real_type, flags);
4349       CHECK_DEPRECATED_NO_RESET (field_decl);
4350
4351       /* If the field denotes a final instance variable, then we
4352          allocate a LANG_DECL_SPECIFIC part to keep track of its
4353          initialization. We also mark whether the field was
4354          initialized upon its declaration. We don't do that if the
4355          created field is an alias to a final local. */
4356       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4357         {
4358           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4359           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4360         }
4361
4362       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4363          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4364          hide parameters to this inner class finit$ and
4365          constructors. It also means that the field isn't final per
4366          say. */
4367       if (ARG_FINAL_P (current))
4368         {
4369           FIELD_LOCAL_ALIAS (field_decl) = 1;
4370           FIELD_FINAL (field_decl) = 0;
4371         }
4372
4373       /* Check if we must chain. */
4374       if (must_chain)
4375         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4376
4377       /* If we have an initialization value tied to the field */
4378       if (init)
4379         {
4380           /* The field is declared static */
4381           if (flags & ACC_STATIC)
4382             {
4383               /* We include the field and its initialization part into
4384                  a list used to generate <clinit>. After <clinit> is
4385                  walked, field initializations will be processed and
4386                  fields initialized with known constants will be taken
4387                  out of <clinit> and have their DECL_INITIAL set
4388                  appropriately. */
4389               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4390               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4391               if (TREE_OPERAND (init, 1)
4392                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4393                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4394             }
4395           /* A non-static field declared with an immediate initialization is
4396              to be initialized in <init>, if any.  This field is remembered
4397              to be processed at the time of the generation of <init>. */
4398           else
4399             {
4400               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4401               SET_CPC_INITIALIZER_STMT (ctxp, init);
4402             }
4403           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4404           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4405         }
4406     }
4407
4408   CLEAR_DEPRECATED;
4409   input_line = saved_lineno;
4410 }
4411
4412 /* Generate finit$, using the list of initialized fields to populate
4413    its body. finit$'s parameter(s) list is adjusted to include the
4414    one(s) used to initialized the field(s) caching outer context
4415    local(s).  */
4416
4417 static tree
4418 generate_finit (tree class_type)
4419 {
4420   int count = 0;
4421   tree list = TYPE_FINIT_STMT_LIST (class_type);
4422   tree mdecl, current, parms;
4423
4424   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4425                                                   class_type, NULL_TREE,
4426                                                   &count);
4427   CRAFTED_PARAM_LIST_FIXUP (parms);
4428   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4429                                     finit_identifier_node, parms);
4430   fix_method_argument_names (parms, mdecl);
4431   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4432                        mdecl, NULL_TREE);
4433   DECL_FUNCTION_NAP (mdecl) = count;
4434   start_artificial_method_body (mdecl);
4435
4436   for (current = list; current; current = TREE_CHAIN (current))
4437     java_method_add_stmt (mdecl,
4438                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4439                                                 current));
4440   end_artificial_method_body (mdecl);
4441   return mdecl;
4442 }
4443
4444 /* Generate a function to run the instance initialization code. The
4445    private method is called `instinit$'. Unless we're dealing with an
4446    anonymous class, we determine whether all ctors of CLASS_TYPE
4447    declare a checked exception in their `throws' clause in order to
4448    see whether it's necessary to encapsulate the instance initializer
4449    statements in a try/catch/rethrow sequence.  */
4450
4451 static tree
4452 generate_instinit (tree class_type)
4453 {
4454   tree current;
4455   tree compound = NULL_TREE;
4456   tree parms = tree_cons (this_identifier_node,
4457                           build_pointer_type (class_type), end_params_node);
4458   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4459                                          void_type_node,
4460                                          instinit_identifier_node, parms);
4461
4462   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4463                        mdecl, NULL_TREE);
4464
4465   /* Gather all the statements in a compound */
4466   for (current = TYPE_II_STMT_LIST (class_type);
4467        current; current = TREE_CHAIN (current))
4468     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4469
4470   /* We need to encapsulate COMPOUND by a try/catch statement to
4471      rethrow exceptions that might occur in the instance initializer.
4472      We do that only if all ctors of CLASS_TYPE are set to catch a
4473      checked exception. This doesn't apply to anonymous classes (since
4474      they don't have declared ctors.) */
4475   if (!ANONYMOUS_CLASS_P (class_type) &&
4476       ctors_unchecked_throws_clause_p (class_type))
4477     {
4478       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4479                                              build1 (THROW_EXPR, NULL_TREE,
4480                                                      build_wfl_node (wpv_id)));
4481       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4482                                                       exception_type_node);
4483     }
4484
4485   start_artificial_method_body (mdecl);
4486   java_method_add_stmt (mdecl, compound);
4487   end_artificial_method_body (mdecl);
4488
4489   return mdecl;
4490 }
4491
4492 /* FIXME */
4493 static tree
4494 build_instinit_invocation (tree class_type)
4495 {
4496   tree to_return = NULL_TREE;
4497
4498   if (TYPE_II_STMT_LIST (class_type))
4499     {
4500       tree parm = build_tree_list (NULL_TREE,
4501                                    build_wfl_node (this_identifier_node));
4502       to_return =
4503         build_method_invocation (build_wfl_node (instinit_identifier_node),
4504                                  parm);
4505     }
4506   return to_return;
4507 }
4508
4509 /* Shared across method_declarator and method_header to remember the
4510    patch stage that was reached during the declaration of the method.
4511    A method DECL is built differently is there is no patch
4512    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4513    pending on the currently defined method.  */
4514
4515 static int patch_stage;
4516
4517 /* Check the method declaration and add the method to its current
4518    class.  If the argument list is known to contain incomplete types,
4519    the method is partially added and the registration will be resume
4520    once the method arguments resolved. If TYPE is NULL, we're dealing
4521    with a constructor.  */
4522
4523 static tree
4524 method_header (int flags, tree type, tree mdecl, tree throws)
4525 {
4526   tree type_wfl = NULL_TREE;
4527   tree meth_name = NULL_TREE;
4528   tree current, orig_arg, this_class = NULL;
4529   tree id, meth;
4530   int saved_lineno;
4531   int constructor_ok = 0, must_chain;
4532   int count;
4533
4534   if (mdecl == error_mark_node)
4535     return error_mark_node;
4536   meth = TREE_VALUE (mdecl);
4537   id = TREE_PURPOSE (mdecl);
4538
4539   check_modifiers_consistency (flags);
4540
4541   if (GET_CPC ())
4542     this_class = TREE_TYPE (GET_CPC ());
4543
4544   if (!this_class || this_class == error_mark_node)
4545     return NULL_TREE;
4546
4547   /* There are some forbidden modifiers for an abstract method and its
4548      class must be abstract as well.  */
4549   if (type && (flags & ACC_ABSTRACT))
4550     {
4551       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4552       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4553       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4554       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4555       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4556       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4557       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4558           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4559         parse_error_context
4560           (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4561            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4562            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4563     }
4564
4565   /* A native method can't be strictfp.  */
4566   if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4567     parse_error_context (id, "native method `%s' can't be strictfp",
4568                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4569   /* No such thing as a transient or volatile method.  */
4570   if ((flags & ACC_TRANSIENT))
4571     parse_error_context (id, "method `%s' can't be transient",
4572                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4573   if ((flags & ACC_VOLATILE))
4574     parse_error_context (id, "method `%s' can't be volatile",
4575                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4576
4577   /* Things to be checked when declaring a constructor */
4578   if (!type)
4579     {
4580       int ec = java_error_count;
4581       /* 8.6: Constructor declarations: we might be trying to define a
4582          method without specifying a return type. */
4583       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4584         parse_error_context
4585           (id, "Invalid method declaration, return type required");
4586       /* 8.6.3: Constructor modifiers */
4587       else
4588         {
4589           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4590           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4591           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4592           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4593           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4594           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4595         }
4596       /* If we found error here, we don't consider it's OK to tread
4597          the method definition as a constructor, for the rest of this
4598          function */
4599       if (ec == java_error_count)
4600         constructor_ok = 1;
4601     }
4602
4603   /* Method declared within the scope of an interface are implicitly
4604      abstract and public. Conflicts with other erroneously provided
4605      modifiers are checked right after. */
4606
4607   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4608     {
4609       /* If FLAGS isn't set because of a modifier, turn the
4610          corresponding modifier WFL to NULL so we issue a warning on
4611          the obsolete use of the modifier */
4612       if (!(flags & ACC_PUBLIC))
4613         MODIFIER_WFL (PUBLIC_TK) = NULL;
4614       if (!(flags & ACC_ABSTRACT))
4615         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4616       flags |= ACC_PUBLIC;
4617       flags |= ACC_ABSTRACT;
4618     }
4619
4620   /* Inner class can't declare static methods */
4621   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4622     {
4623       parse_error_context
4624         (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4625          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4626          lang_printable_name (this_class, 0));
4627     }
4628
4629   /* Modifiers context reset moved up, so abstract method declaration
4630      modifiers can be later checked.  */
4631
4632   /* Set constructor returned type to void and method name to <init>,
4633      unless we found an error identifier the constructor (in which
4634      case we retain the original name) */
4635   if (!type)
4636     {
4637       type = void_type_node;
4638       if (constructor_ok)
4639         meth_name = init_identifier_node;
4640     }
4641   else
4642     meth_name = EXPR_WFL_NODE (id);
4643
4644   /* Do the returned type resolution and registration if necessary */
4645   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4646
4647   if (meth_name)
4648     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4649   EXPR_WFL_NODE (id) = meth_name;
4650   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4651
4652   if (must_chain)
4653     {
4654       patch_stage = JDEP_METHOD_RETURN;
4655       register_incomplete_type (patch_stage, type_wfl, id, type);
4656       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4657     }
4658   else
4659     TREE_TYPE (meth) = type;
4660
4661   saved_lineno = input_line;
4662   /* When defining an abstract or interface method, the curly
4663      bracket at level 1 doesn't exist because there is no function
4664      body */
4665   input_line = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4666             EXPR_WFL_LINENO (id));
4667
4668   /* Remember the original argument list */
4669   orig_arg = TYPE_ARG_TYPES (meth);
4670
4671   if (patch_stage)              /* includes ret type and/or all args */
4672     {
4673       jdep *jdep;
4674       meth = add_method_1 (this_class, flags, meth_name, meth);
4675       /* Patch for the return type */
4676       if (patch_stage == JDEP_METHOD_RETURN)
4677         {
4678           jdep = CLASSD_LAST (ctxp->classd_list);
4679           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4680         }
4681       /* This is the stop JDEP. METH allows the function's signature
4682          to be computed. */
4683       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4684     }
4685   else
4686     meth = add_method (this_class, flags, meth_name,
4687                        build_java_signature (meth));
4688
4689   /* Remember final parameters */
4690   MARK_FINAL_PARMS (meth, orig_arg);
4691
4692   /* Fix the method argument list so we have the argument name
4693      information */
4694   fix_method_argument_names (orig_arg, meth);
4695
4696   /* Register the parameter number and re-install the current line
4697      number */
4698   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4699   input_line = saved_lineno;
4700
4701   /* Register exception specified by the `throws' keyword for
4702      resolution and set the method decl appropriate field to the list.
4703      Note: the grammar ensures that what we get here are class
4704      types. */
4705   if (throws)
4706     {
4707       throws = nreverse (throws);
4708       for (current = throws; current; current = TREE_CHAIN (current))
4709         {
4710           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4711                                     NULL_TREE, NULL_TREE);
4712           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4713             &TREE_VALUE (current);
4714         }
4715       DECL_FUNCTION_THROWS (meth) = throws;
4716     }
4717
4718   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4719     DECL_FUNCTION_WFL (meth) = id;
4720
4721   /* Set the flag if we correctly processed a constructor */
4722   if (constructor_ok)
4723     {
4724       DECL_CONSTRUCTOR_P (meth) = 1;
4725       /* Compute and store the number of artificial parameters declared
4726          for this constructor */
4727       for (count = 0, current = TYPE_FIELDS (this_class); current;
4728            current = TREE_CHAIN (current))
4729         if (FIELD_LOCAL_ALIAS (current))
4730           count++;
4731       DECL_FUNCTION_NAP (meth) = count;
4732     }
4733
4734   /* Eventually set the @deprecated tag flag */
4735   CHECK_DEPRECATED (meth);
4736
4737   /* If doing xref, store column and line number information instead
4738      of the line number only. */
4739   if (flag_emit_xref)
4740     DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4741
4742   return meth;
4743 }
4744
4745 static void
4746 fix_method_argument_names (tree orig_arg, tree meth)
4747 {
4748   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4749   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4750     {
4751       TREE_PURPOSE (arg) = this_identifier_node;
4752       arg = TREE_CHAIN (arg);
4753     }
4754   while (orig_arg != end_params_node)
4755     {
4756       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4757       orig_arg = TREE_CHAIN (orig_arg);
4758       arg = TREE_CHAIN (arg);
4759     }
4760 }
4761
4762 /* Complete the method declaration with METHOD_BODY.  */
4763
4764 static void
4765 finish_method_declaration (tree method_body)
4766 {
4767   int flags;
4768
4769   if (!current_function_decl)
4770     return;
4771
4772   flags = get_access_flags_from_decl (current_function_decl);
4773
4774   /* 8.4.5 Method Body */
4775   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4776     {
4777       tree name = DECL_NAME (current_function_decl);
4778       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4779                            "%s method `%s' can't have a body defined",
4780                            (METHOD_NATIVE (current_function_decl) ?
4781                             "Native" : "Abstract"),
4782                            IDENTIFIER_POINTER (name));
4783       method_body = NULL_TREE;
4784     }
4785   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4786     {
4787       tree name = DECL_NAME (current_function_decl);
4788       parse_error_context
4789         (DECL_FUNCTION_WFL (current_function_decl),
4790          "Non native and non abstract method `%s' must have a body defined",
4791          IDENTIFIER_POINTER (name));
4792       method_body = NULL_TREE;
4793     }
4794
4795   if (flag_emit_class_files && method_body
4796       && TREE_CODE (method_body) == NOP_EXPR
4797       && TREE_TYPE (current_function_decl)
4798       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4799     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4800
4801   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4802   maybe_absorb_scoping_blocks ();
4803   /* Exit function's body */
4804   exit_block ();
4805   /* Merge last line of the function with first line, directly in the
4806      function decl. It will be used to emit correct debug info. */
4807   if (!flag_emit_xref)
4808     DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4809
4810   /* Since function's argument's list are shared, reset the
4811      ARG_FINAL_P parameter that might have been set on some of this
4812      function parameters. */
4813   UNMARK_FINAL_PARMS (current_function_decl);
4814
4815   /* So we don't have an irrelevant function declaration context for
4816      the next static block we'll see. */
4817   current_function_decl = NULL_TREE;
4818 }
4819
4820 /* Build a an error message for constructor circularity errors.  */
4821
4822 static char *
4823 constructor_circularity_msg (tree from, tree to)
4824 {
4825   static char string [4096];
4826   char *t = xstrdup (lang_printable_name (from, 0));
4827   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4828   free (t);
4829   return string;
4830 }
4831
4832 /* Verify a circular call to METH. Return 1 if an error is found, 0
4833    otherwise.  */
4834
4835 static GTY(()) tree vcc_list;
4836 static int
4837 verify_constructor_circularity (tree meth, tree current)
4838 {
4839   tree c;
4840
4841   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4842     {
4843       if (TREE_VALUE (c) == meth)
4844         {
4845           char *t;
4846           if (vcc_list)
4847             {
4848               tree liste;
4849               vcc_list = nreverse (vcc_list);
4850               for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4851                 {
4852                   parse_error_context
4853                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4854                      constructor_circularity_msg
4855                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4856                   java_error_count--;
4857                 }
4858             }
4859           t = xstrdup (lang_printable_name (meth, 0));
4860           parse_error_context (TREE_PURPOSE (c),
4861                                "%s: recursive invocation of constructor `%s'",
4862                                constructor_circularity_msg (current, meth), t);
4863           free (t);
4864           vcc_list = NULL_TREE;
4865           return 1;
4866         }
4867     }
4868   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4869     {
4870       vcc_list = tree_cons (c, current, vcc_list);
4871       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4872         return 1;
4873       vcc_list = TREE_CHAIN (vcc_list);
4874     }
4875   return 0;
4876 }
4877
4878 /* Check modifiers that can be declared but exclusively */
4879
4880 static void
4881 check_modifiers_consistency (int flags)
4882 {
4883   int acc_count = 0;
4884   tree cl = NULL_TREE;
4885
4886   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4887   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4888   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4889   if (acc_count > 1)
4890     parse_error_context
4891       (cl, "Inconsistent member declaration.  At most one of `public', `private', or `protected' may be specified");
4892
4893   acc_count = 0;
4894   cl = NULL_TREE;
4895   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4896   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4897   if (acc_count > 1)
4898     parse_error_context (cl,
4899                          "Inconsistent member declaration.  At most one of `final' or `volatile' may be specified");
4900 }
4901
4902 /* Check the methode header METH for abstract specifics features */
4903
4904 static void
4905 check_abstract_method_header (tree meth)
4906 {
4907   int flags = get_access_flags_from_decl (meth);
4908
4909   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4910                               ACC_ABSTRACT, "abstract method",
4911                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4912   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4913                               ACC_PUBLIC, "abstract method",
4914                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4915
4916   check_modifiers ("Illegal modifier `%s' for interface method",
4917                   flags, INTERFACE_METHOD_MODIFIERS);
4918 }
4919
4920 /* Create a FUNCTION_TYPE node and start augmenting it with the
4921    declared function arguments. Arguments type that can't be resolved
4922    are left as they are, but the returned node is marked as containing
4923    incomplete types.  */
4924
4925 static tree
4926 method_declarator (tree id, tree list)
4927 {
4928   tree arg_types = NULL_TREE, current, node;
4929   tree meth = make_node (FUNCTION_TYPE);
4930   jdep *jdep;
4931
4932   patch_stage = JDEP_NO_PATCH;
4933
4934   if (GET_CPC () == error_mark_node)
4935     return error_mark_node;
4936
4937   /* If we're dealing with an inner class constructor, we hide the
4938      this$<n> decl in the name field of its parameter declaration.  We
4939      also might have to hide the outer context local alias
4940      initializers. Not done when the class is a toplevel class. */
4941   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4942       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4943     {
4944       tree aliases_list, type, thisn;
4945       /* First the aliases, linked to the regular parameters */
4946       aliases_list =
4947         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4948                                                 TREE_TYPE (GET_CPC ()),
4949                                                 NULL_TREE, NULL);
4950       list = chainon (nreverse (aliases_list), list);
4951
4952       /* Then this$<n> */
4953       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4954       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4955       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4956                         list);
4957     }
4958
4959   for (current = list; current; current = TREE_CHAIN (current))
4960     {
4961       int must_chain = 0;
4962       tree wfl_name = TREE_PURPOSE (current);
4963       tree type = TREE_VALUE (current);
4964       tree name = EXPR_WFL_NODE (wfl_name);
4965       tree already, arg_node;
4966       tree type_wfl = NULL_TREE;
4967       tree real_type;
4968
4969       /* Obtain a suitable type for resolution, if necessary */
4970       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4971
4972       /* Process NAME, as it may specify extra dimension(s) for it */
4973       type = build_array_from_name (type, type_wfl, name, &name);
4974       EXPR_WFL_NODE (wfl_name) = name;
4975
4976       real_type = GET_REAL_TYPE (type);
4977       if (TREE_CODE (real_type) == RECORD_TYPE)
4978         {
4979           real_type = promote_type (real_type);
4980           if (TREE_CODE (type) == TREE_LIST)
4981             TREE_PURPOSE (type) = real_type;
4982         }
4983
4984       /* Check redefinition */
4985       for (already = arg_types; already; already = TREE_CHAIN (already))
4986         if (TREE_PURPOSE (already) == name)
4987           {
4988             parse_error_context
4989               (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4990                IDENTIFIER_POINTER (name),
4991                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4992             break;
4993           }
4994
4995       /* If we've an incomplete argument type, we know there is a location
4996          to patch when the type get resolved, later.  */
4997       jdep = NULL;
4998       if (must_chain)
4999         {
5000           patch_stage = JDEP_METHOD;
5001           type = register_incomplete_type (patch_stage,
5002                                            type_wfl, wfl_name, type);
5003           jdep = CLASSD_LAST (ctxp->classd_list);
5004           JDEP_MISC (jdep) = id;
5005         }
5006
5007       /* The argument node: a name and a (possibly) incomplete type.  */
5008       arg_node = build_tree_list (name, real_type);
5009       /* Remember arguments declared final. */
5010       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
5011
5012       if (jdep)
5013         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
5014       TREE_CHAIN (arg_node) = arg_types;
5015       arg_types = arg_node;
5016     }
5017   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
5018   node = build_tree_list (id, meth);
5019   return node;
5020 }
5021
5022 static int
5023 unresolved_type_p (tree wfl, tree *returned)
5024
5025 {
5026   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5027     {
5028       if (returned)
5029         {
5030           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5031           if (decl && current_class && (decl == TYPE_NAME (current_class)))
5032             *returned = TREE_TYPE (decl);
5033           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5034             *returned = TREE_TYPE (GET_CPC ());
5035           else
5036             *returned = NULL_TREE;
5037         }
5038       return 1;
5039     }
5040   if (returned)
5041     *returned = wfl;
5042   return 0;
5043 }
5044
5045 /* From NAME, build a qualified identifier node using the
5046    qualification from the current package definition. */
5047
5048 static tree
5049 parser_qualified_classname (tree name)
5050 {
5051   tree nested_class_name;
5052
5053   if ((nested_class_name = maybe_make_nested_class_name (name)))
5054     return nested_class_name;
5055
5056   if (ctxp->package)
5057     return merge_qualified_name (ctxp->package, name);
5058   else
5059     return name;
5060 }
5061
5062 /* Called once the type a interface extends is resolved. Returns 0 if
5063    everything is OK.  */
5064
5065 static int
5066 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5067 {
5068   tree super_type = TREE_TYPE (super_decl);
5069
5070   /* Has to be an interface */
5071   if (!CLASS_INTERFACE (super_decl))
5072     {
5073       parse_error_context
5074         (this_wfl, "%s `%s' can't implement/extend %s `%s'",
5075          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5076           "Interface" : "Class"),
5077          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5078          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5079          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5080       return 1;
5081     }
5082
5083   /* Check top-level interface access. Inner classes are subject to member
5084      access rules (6.6.1). */
5085   if (! INNER_CLASS_P (super_type)
5086       && check_pkg_class_access (DECL_NAME (super_decl),
5087                                  NULL_TREE, true, this_decl))
5088     return 1;
5089
5090   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5091                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5092                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5093   return 0;
5094 }
5095
5096 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5097    0 if everything is OK.  */
5098
5099 static int
5100 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5101 {
5102   tree super_type = TREE_TYPE (super_decl);
5103
5104   /* SUPER should be a CLASS (neither an array nor an interface) */
5105   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5106     {
5107       parse_error_context
5108         (wfl, "Class `%s' can't subclass %s `%s'",
5109          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5110          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5111          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5112       return 1;
5113     }
5114
5115   if (CLASS_FINAL (TYPE_NAME (super_type)))
5116     {
5117       parse_error_context (wfl, "Can't subclass final classes: %s",
5118                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5119       return 1;
5120     }
5121
5122   /* Check top-level class scope. Inner classes are subject to member access
5123      rules (6.6.1). */
5124   if (! INNER_CLASS_P (super_type)
5125       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true, NULL_TREE)))
5126     return 1;
5127
5128   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5129                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5130                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5131   return 0;
5132 }
5133
5134 /* Create a new dependency list and link it (in a LIFO manner) to the
5135    CTXP list of type dependency list.  */
5136
5137 static void
5138 create_jdep_list (struct parser_ctxt *ctxp)
5139 {
5140   jdeplist *new = xmalloc (sizeof (jdeplist));
5141   new->first = new->last = NULL;
5142   new->next = ctxp->classd_list;
5143   ctxp->classd_list = new;
5144 }
5145
5146 static jdeplist *
5147 reverse_jdep_list (struct parser_ctxt *ctxp)
5148 {
5149   jdeplist *prev = NULL, *current, *next;
5150   for (current = ctxp->classd_list; current; current = next)
5151     {
5152       next = current->next;
5153       current->next = prev;
5154       prev = current;
5155     }
5156   return prev;
5157 }
5158
5159 /* Create a fake pointer based on the ID stored in
5160    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5161    registered again. */
5162
5163 static tree
5164 obtain_incomplete_type (tree type_name)
5165 {
5166   tree ptr = NULL_TREE, name;
5167
5168   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5169     name = EXPR_WFL_NODE (type_name);
5170   else if (INCOMPLETE_TYPE_P (type_name))
5171     name = TYPE_NAME (type_name);
5172   else
5173     abort ();
5174
5175   /* Workaround from build_pointer_type for incomplete types.  */
5176   BUILD_PTR_FROM_NAME (ptr, name);
5177   TYPE_MODE (ptr) = ptr_mode;
5178   layout_type (ptr);
5179
5180   return ptr;
5181 }
5182
5183 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5184    non NULL instead of computing a new fake type based on WFL. The new
5185    dependency is inserted in the current type dependency list, in FIFO
5186    manner.  */
5187
5188 static tree
5189 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5190 {
5191   jdep *new = xmalloc (sizeof (jdep));
5192
5193   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5194     ptr = obtain_incomplete_type (wfl);
5195
5196   JDEP_KIND (new) = kind;
5197   JDEP_DECL (new) = decl;
5198   JDEP_TO_RESOLVE (new) = ptr;
5199   JDEP_WFL (new) = wfl;
5200   JDEP_CHAIN (new) = NULL;
5201   JDEP_MISC (new) = NULL_TREE;
5202   /* For some dependencies, set the enclosing class of the current
5203      class to be the enclosing context */
5204   if ((kind == JDEP_INTERFACE  || kind == JDEP_ANONYMOUS)
5205       && GET_ENCLOSING_CPC ())
5206     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5207   else if (kind == JDEP_SUPER)
5208     JDEP_ENCLOSING (new) = (GET_ENCLOSING_CPC () ?
5209                             TREE_VALUE (GET_ENCLOSING_CPC ()) : NULL_TREE);
5210   else
5211     JDEP_ENCLOSING (new) = GET_CPC ();
5212   JDEP_GET_PATCH (new) = (tree *)NULL;
5213
5214   JDEP_INSERT (ctxp->classd_list, new);
5215
5216   return ptr;
5217 }
5218
5219 /* This checks for circular references with innerclasses. We start
5220    from SOURCE and should never reach TARGET. Extended/implemented
5221    types in SOURCE have their enclosing context checked not to reach
5222    TARGET. When the last enclosing context of SOURCE is reached, its
5223    extended/implemented types are also checked not to reach TARGET.
5224    In case of error, WFL of the offending type is returned; NULL_TREE
5225    otherwise.  */
5226
5227 static tree
5228 check_inner_circular_reference (tree source, tree target)
5229 {
5230   tree basetype_vec = TYPE_BINFO_BASETYPES (source);
5231   tree ctx, cl;
5232   int i;
5233
5234   if (!basetype_vec)
5235     return NULL_TREE;
5236
5237   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5238     {
5239       tree su;
5240
5241       /* We can end up with a NULL_TREE or an incomplete type here if
5242          we encountered previous type resolution errors. It's safe to
5243          simply ignore these cases.  */
5244       if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
5245         continue;
5246       su = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
5247       if (INCOMPLETE_TYPE_P (su))
5248         continue;
5249
5250       if (inherits_from_p (su, target))
5251         return lookup_cl (TYPE_NAME (su));
5252
5253       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5254         {
5255           /* An enclosing context shouldn't be TARGET */
5256           if (ctx == TYPE_NAME (target))
5257             return lookup_cl (TYPE_NAME (su));
5258
5259           /* When we reach the enclosing last context, start a check
5260              on it, with the same target */
5261           if (! DECL_CONTEXT (ctx) &&
5262               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5263             return cl;
5264         }
5265     }
5266   return NULL_TREE;
5267 }
5268
5269 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5270    offending type if a circularity is detected. NULL_TREE is returned
5271    otherwise. TYPE can be an interface or a class.   */
5272
5273 static tree
5274 check_circular_reference (tree type)
5275 {
5276   tree basetype_vec = TYPE_BINFO_BASETYPES (type);
5277   int i;
5278
5279   if (!basetype_vec)
5280     return NULL_TREE;
5281
5282   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5283     {
5284       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5285         return lookup_cl (TYPE_NAME (type));
5286       return NULL_TREE;
5287     }
5288
5289   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5290     {
5291       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
5292       if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
5293           && interface_of_p (type, BINFO_TYPE (vec_elt)))
5294         return lookup_cl (TYPE_NAME (BINFO_TYPE (vec_elt)));
5295     }
5296   return NULL_TREE;
5297 }
5298
5299 void
5300 java_check_circular_reference (void)
5301 {
5302   tree current;
5303   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5304     {
5305       tree type = TREE_TYPE (current);
5306       tree cl;
5307
5308       cl = check_circular_reference (type);
5309       if (! cl)
5310         cl = check_inner_circular_reference (type, type);
5311       if (cl)
5312         parse_error_context (cl, "Cyclic class inheritance%s",
5313                              (cyclic_inheritance_report ?
5314                               cyclic_inheritance_report : ""));
5315     }
5316 }
5317
5318 /* Augment the parameter list PARM with parameters crafted to
5319    initialize outer context locals aliases. Through ARTIFICIAL, a
5320    count is kept of the number of crafted parameters. MODE governs
5321    what eventually gets created: something suitable for a function
5322    creation or a function invocation, either the constructor or
5323    finit$.  */
5324
5325 static tree
5326 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5327                                         int *artificial)
5328 {
5329   tree field;
5330   tree additional_parms = NULL_TREE;
5331
5332   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5333     if (FIELD_LOCAL_ALIAS (field))
5334       {
5335         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5336         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5337         tree mangled_id;
5338
5339         switch (mode)
5340           {
5341           case AIPL_FUNCTION_DECLARATION:
5342             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5343                                                          &buffer [4]);
5344             purpose = build_wfl_node (mangled_id);
5345             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5346               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5347             else
5348               value = TREE_TYPE (field);
5349             break;
5350
5351           case AIPL_FUNCTION_CREATION:
5352             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5353                                                          &buffer [4]);
5354             value = TREE_TYPE (field);
5355             break;
5356
5357           case AIPL_FUNCTION_FINIT_INVOCATION:
5358             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5359                                                          &buffer [4]);
5360             /* Now, this is wrong. purpose should always be the NAME
5361                of something and value its matching value (decl, type,
5362                etc...) FIXME -- but there is a lot to fix. */
5363
5364             /* When invoked for this kind of operation, we already
5365                know whether a field is used or not. */
5366             purpose = TREE_TYPE (field);
5367             value = build_wfl_node (mangled_id);
5368             break;
5369
5370           case AIPL_FUNCTION_CTOR_INVOCATION:
5371             /* There are two case: the constructor invocation happens
5372                outside the local inner, in which case, locales from the outer
5373                context are directly used.
5374
5375                Otherwise, we fold to using the alias directly. */
5376             if (class_type == current_class)
5377               value = field;
5378             else
5379               {
5380                 name = get_identifier (&buffer[4]);
5381                 value = IDENTIFIER_LOCAL_VALUE (name);
5382               }
5383             break;
5384           }
5385         additional_parms = tree_cons (purpose, value, additional_parms);
5386         if (artificial)
5387           *artificial +=1;
5388       }
5389   if (additional_parms)
5390     {
5391       if (ANONYMOUS_CLASS_P (class_type)
5392           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5393         additional_parms = nreverse (additional_parms);
5394       parm = chainon (additional_parms, parm);
5395     }
5396
5397    return parm;
5398 }
5399
5400 /* Craft a constructor for CLASS_DECL -- what we should do when none
5401    where found. ARGS is non NULL when a special signature must be
5402    enforced. This is the case for anonymous classes.  */
5403
5404 static tree
5405 craft_constructor (tree class_decl, tree args)
5406 {
5407   tree class_type = TREE_TYPE (class_decl);
5408   tree parm = NULL_TREE;
5409   int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5410                ACC_PUBLIC : 0);
5411   int i = 0, artificial = 0;
5412   tree decl, ctor_name;
5413   char buffer [80];
5414
5415   /* The constructor name is <init> unless we're dealing with an
5416      anonymous class, in which case the name will be fixed after having
5417      be expanded. */
5418   if (ANONYMOUS_CLASS_P (class_type))
5419     ctor_name = DECL_NAME (class_decl);
5420   else
5421     ctor_name = init_identifier_node;
5422
5423   /* If we're dealing with an inner class constructor, we hide the
5424      this$<n> decl in the name field of its parameter declaration. */
5425   if (PURE_INNER_CLASS_TYPE_P (class_type))
5426     {
5427       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5428       parm = tree_cons (build_current_thisn (class_type),
5429                         build_pointer_type (type), parm);
5430
5431       /* Some more arguments to be hidden here. The values of the local
5432          variables of the outer context that the inner class needs to see. */
5433       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5434                                                      class_type, parm,
5435                                                      &artificial);
5436     }
5437
5438   /* Then if there are any args to be enforced, enforce them now */
5439   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5440     {
5441       sprintf (buffer, "parm%d", i++);
5442       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5443     }
5444
5445   CRAFTED_PARAM_LIST_FIXUP (parm);
5446   decl = create_artificial_method (class_type, flags, void_type_node,
5447                                    ctor_name, parm);
5448   fix_method_argument_names (parm, decl);
5449   /* Now, mark the artificial parameters. */
5450   DECL_FUNCTION_NAP (decl) = artificial;
5451   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5452   DECL_INLINE (decl) = 1;
5453   return decl;
5454 }
5455
5456
5457 /* Fix the constructors. This will be called right after circular
5458    references have been checked. It is necessary to fix constructors
5459    early even if no code generation will take place for that class:
5460    some generated constructor might be required by the class whose
5461    compilation triggered this one to be simply loaded.  */
5462
5463 void
5464 java_fix_constructors (void)
5465 {
5466   tree current;
5467
5468   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5469     {
5470       tree class_type = TREE_TYPE (current);
5471       int saw_ctor = 0;
5472       tree decl;
5473
5474       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5475         continue;
5476
5477       output_class = current_class = class_type;
5478       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5479         {
5480           if (DECL_CONSTRUCTOR_P (decl))
5481             {
5482               fix_constructors (decl);
5483               saw_ctor = 1;
5484             }
5485         }
5486
5487       /* Anonymous class constructor can't be generated that early. */
5488       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5489         craft_constructor (current, NULL_TREE);
5490     }
5491 }
5492
5493 /* safe_layout_class just makes sure that we can load a class without
5494    disrupting the current_class, input_file, lineno, etc, information
5495    about the class processed currently.  */
5496
5497 void
5498 safe_layout_class (tree class)
5499 {
5500   tree save_current_class = current_class;
5501   location_t save_location = input_location;
5502
5503   layout_class (class);
5504
5505   current_class = save_current_class;
5506   input_location = save_location;
5507 }
5508
5509 static tree
5510 jdep_resolve_class (jdep *dep)
5511 {
5512   tree decl;
5513
5514   if (JDEP_RESOLVED_P (dep))
5515     decl = JDEP_RESOLVED_DECL (dep);
5516   else
5517     {
5518       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5519                             JDEP_DECL (dep), JDEP_WFL (dep));
5520       JDEP_RESOLVED (dep, decl);
5521       /* If there is no WFL, that's ok.  We generate this warning
5522          elsewhere.  */
5523       if (decl && JDEP_WFL (dep) != NULL_TREE)
5524         check_deprecation (JDEP_WFL (dep), decl);
5525     }
5526
5527   if (!decl)
5528     complete_class_report_errors (dep);
5529   else if (PURE_INNER_CLASS_DECL_P (decl))
5530     {
5531       tree inner = TREE_TYPE (decl);
5532       if (! CLASS_LOADED_P (inner))
5533         {
5534           safe_layout_class (inner);
5535           if (TYPE_SIZE (inner) == error_mark_node)
5536             TYPE_SIZE (inner) = NULL_TREE;
5537         }
5538       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5539     }
5540   return decl;
5541 }
5542
5543 /* Complete unsatisfied class declaration and their dependencies */
5544
5545 void
5546 java_complete_class (void)
5547 {
5548   tree cclass;
5549   jdeplist *cclassd;
5550   int error_found;
5551   tree type;
5552
5553   /* Process imports */
5554   process_imports ();
5555
5556   /* Reverse things so we have the right order */
5557   ctxp->class_list = nreverse (ctxp->class_list);
5558   ctxp->classd_list = reverse_jdep_list (ctxp);
5559
5560   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5561        cclass && cclassd;
5562        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5563     {
5564       jdep *dep;
5565
5566       /* We keep the compilation unit imports in the class so that
5567          they can be used later to resolve type dependencies that
5568          aren't necessary to solve now. */
5569       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5570       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5571
5572       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5573         {
5574           tree decl;
5575           if (!(decl = jdep_resolve_class (dep)))
5576             continue;
5577
5578           /* Now it's time to patch */
5579           switch (JDEP_KIND (dep))
5580             {
5581             case JDEP_SUPER:
5582               /* Simply patch super */
5583               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5584                 continue;
5585               BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5586                 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5587               break;
5588
5589             case JDEP_FIELD:
5590               {
5591                 /* We do part of the job done in add_field */
5592                 tree field_decl = JDEP_DECL (dep);
5593                 tree field_type = TREE_TYPE (decl);
5594                 if (TREE_CODE (field_type) == RECORD_TYPE)
5595                   field_type = promote_type (field_type);
5596                 TREE_TYPE (field_decl) = field_type;
5597                 DECL_ALIGN (field_decl) = 0;
5598                 DECL_USER_ALIGN (field_decl) = 0;
5599                 layout_decl (field_decl, 0);
5600                 SOURCE_FRONTEND_DEBUG
5601                   (("Completed field/var decl `%s' with `%s'",
5602                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5603                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5604                 break;
5605               }
5606             case JDEP_METHOD:   /* We start patching a method */
5607             case JDEP_METHOD_RETURN:
5608               error_found = 0;
5609               while (1)
5610                 {
5611                   if (decl)
5612                     {
5613                       type = TREE_TYPE(decl);
5614                       if (TREE_CODE (type) == RECORD_TYPE)
5615                         type = promote_type (type);
5616                       JDEP_APPLY_PATCH (dep, type);
5617                       SOURCE_FRONTEND_DEBUG
5618                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5619                            "Completing fct `%s' with ret type `%s'":
5620                            "Completing arg `%s' with type `%s'"),
5621                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5622                                               (JDEP_DECL_WFL (dep))),
5623                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5624                     }
5625                   else
5626                     error_found = 1;
5627                   dep = JDEP_CHAIN (dep);
5628                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5629                     break;
5630                   else
5631                     decl = jdep_resolve_class (dep);
5632                 }
5633               if (!error_found)
5634                 {
5635                   tree mdecl = JDEP_DECL (dep), signature;
5636                   /* Recompute and reset the signature, check first that
5637                      all types are now defined. If they're not,
5638                      don't build the signature. */
5639                   if (check_method_types_complete (mdecl))
5640                     {
5641                       signature = build_java_signature (TREE_TYPE (mdecl));
5642                       set_java_signature (TREE_TYPE (mdecl), signature);
5643                     }
5644                 }
5645               else
5646                 continue;
5647               break;
5648
5649             case JDEP_INTERFACE:
5650               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5651                                                 JDEP_WFL (dep)))
5652                 continue;
5653               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5654               break;
5655
5656             case JDEP_PARM:
5657             case JDEP_VARIABLE:
5658               type = TREE_TYPE(decl);
5659               if (TREE_CODE (type) == RECORD_TYPE)
5660                 type = promote_type (type);
5661               JDEP_APPLY_PATCH (dep, type);
5662               break;
5663
5664             case JDEP_TYPE:
5665               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5666               SOURCE_FRONTEND_DEBUG
5667                 (("Completing a random type dependency on a '%s' node",
5668                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5669               break;
5670
5671             case JDEP_EXCEPTION:
5672               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5673               SOURCE_FRONTEND_DEBUG
5674                 (("Completing `%s' `throws' argument node",
5675                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5676               break;
5677
5678             case JDEP_ANONYMOUS:
5679               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5680               break;
5681
5682             default:
5683               abort ();
5684             }
5685         }
5686     }
5687   return;
5688 }
5689
5690 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5691    array.  */
5692
5693 static tree
5694 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5695 {
5696   tree tname = TYPE_NAME (class_type);
5697   tree resolved_type = TREE_TYPE (class_type);
5698   int array_dims = 0;
5699   tree resolved_type_decl;
5700
5701   if (resolved_type != NULL_TREE)
5702     {
5703       tree resolved_type_decl = TYPE_NAME (resolved_type);
5704       if (resolved_type_decl == NULL_TREE
5705           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5706         {
5707           resolved_type_decl = build_decl (TYPE_DECL,
5708                                            TYPE_NAME (class_type),
5709                                            resolved_type);
5710         }
5711       return resolved_type_decl;
5712     }
5713
5714   /* 1- Check to see if we have an array. If true, find what we really
5715      want to resolve  */
5716   if ((array_dims = build_type_name_from_array_name (tname,
5717                                                      &TYPE_NAME (class_type))))
5718     WFL_STRIP_BRACKET (cl, cl);
5719
5720   /* 2- Resolve the bare type */
5721   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5722                                                decl, cl)))
5723     return NULL_TREE;
5724   resolved_type = TREE_TYPE (resolved_type_decl);
5725
5726   /* 3- If we have an array, reconstruct the array down to its nesting */
5727   if (array_dims)
5728     {
5729       for (; array_dims; array_dims--)
5730         resolved_type = build_java_array_type (resolved_type, -1);
5731       resolved_type_decl = TYPE_NAME (resolved_type);
5732     }
5733   TREE_TYPE (class_type) = resolved_type;
5734   return resolved_type_decl;
5735 }
5736
5737 /* Effectively perform the resolution of class CLASS_TYPE.  DECL or CL
5738    are used to report error messages; CL must either be NULL_TREE or a
5739    WFL wrapping a class.  Do not try to replace TYPE_NAME (class_type)
5740    by a variable, since it is changed by find_in_imports{_on_demand}
5741    and (but it doesn't really matter) qualify_and_find.  */
5742
5743 tree
5744 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5745 {
5746   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5747   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5748   tree decl_result;
5749   htab_t circularity_hash;
5750
5751   if (QUALIFIED_P (TYPE_NAME (class_type)))
5752     {
5753       /* If the type name is of the form `Q . Id', then Q is either a
5754          package name or a class name.  First we try to find Q as a
5755          class and then treat Id as a member type.  If we can't find Q
5756          as a class then we fall through.  */
5757       tree q, left, left_type, right;
5758       if (breakdown_qualified (&left, &right, TYPE_NAME (class_type)) == 0)
5759         {
5760           BUILD_PTR_FROM_NAME (left_type, left);
5761           q = do_resolve_class (enclosing, left_type, decl, cl);
5762           if (q)
5763             {
5764               enclosing = q;
5765               saved_enclosing_type = TREE_TYPE (q);
5766               BUILD_PTR_FROM_NAME (class_type, right);
5767             }
5768         }
5769     }
5770
5771   if (enclosing)
5772     {
5773       /* This hash table is used to register the classes we're going
5774          through when searching the current class as an inner class, in
5775          order to detect circular references. Remember to free it before
5776          returning the section 0- of this function. */
5777       circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5778                                       NULL);
5779
5780       /* 0- Search in the current class as an inner class.
5781          Maybe some code here should be added to load the class or
5782          something, at least if the class isn't an inner class and ended
5783          being loaded from class file. FIXME. */
5784       while (enclosing)
5785         {
5786           new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5787                                                 &super, class_type);
5788           if (new_class_decl)
5789             break;
5790
5791           /* If we haven't found anything because SUPER reached Object and
5792              ENCLOSING happens to be an innerclass, try the enclosing context. */
5793           if ((!super || super == object_type_node) &&
5794               enclosing && INNER_CLASS_DECL_P (enclosing))
5795             enclosing = DECL_CONTEXT (enclosing);
5796           else
5797             enclosing = NULL_TREE;
5798         }
5799
5800       htab_delete (circularity_hash);
5801
5802       if (new_class_decl)
5803         return new_class_decl;
5804     }
5805
5806   /* 1- Check for the type in single imports. This will change
5807      TYPE_NAME() if something relevant is found */
5808   find_in_imports (saved_enclosing_type, class_type);
5809
5810   /* 2- And check for the type in the current compilation unit */
5811   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5812     {
5813       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5814           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5815         load_class (TYPE_NAME (class_type), 0);
5816       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5817     }
5818
5819   /* 3- Search according to the current package definition */
5820   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5821     {
5822       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5823                                              TYPE_NAME (class_type))))
5824         return new_class_decl;
5825     }
5826
5827   /* 4- Check the import on demands. Don't allow bar.baz to be
5828      imported from foo.* */
5829   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5830     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5831       return NULL_TREE;
5832
5833   /* If found in find_in_imports_on_demand, the type has already been
5834      loaded. */
5835   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5836     return new_class_decl;
5837
5838   /* 5- Try with a name qualified with the package name we've seen so far */
5839   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5840     {
5841       tree package;
5842
5843       /* If there is a current package (ctxp->package), it's the first
5844          element of package_list and we can skip it. */
5845       for (package = (ctxp->package ?
5846                       TREE_CHAIN (package_list) : package_list);
5847            package; package = TREE_CHAIN (package))
5848         if ((new_class_decl = qualify_and_find (class_type,
5849                                                TREE_PURPOSE (package),
5850                                                TYPE_NAME (class_type))))
5851           return new_class_decl;
5852     }
5853
5854   /* 5- Check another compilation unit that bears the name of type */
5855   load_class (TYPE_NAME (class_type), 0);
5856
5857   if (!cl)
5858     cl = lookup_cl (decl);
5859
5860   /* If we don't have a value for CL, then we're being called recursively.
5861      We can't check package access just yet, but it will be taken care of
5862      by the caller. */
5863   if (cl)
5864     {
5865       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true, NULL_TREE))
5866         return NULL_TREE;
5867     }
5868
5869   /* 6- Last call for a resolution */
5870   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5871
5872   /* The final lookup might have registered a.b.c into a.b$c If we
5873      failed at the first lookup, progressively change the name if
5874      applicable and use the matching DECL instead. */
5875   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5876     {
5877       char *separator;
5878       tree name = TYPE_NAME (class_type);
5879       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
5880
5881       strcpy (namebuffer, IDENTIFIER_POINTER (name));
5882
5883       do {
5884
5885        /* Reach the last '.', and if applicable, replace it by a `$' and
5886           see if this exists as a type. */
5887        if ((separator = strrchr (namebuffer, '.')))
5888          {
5889            *separator = '$';
5890            name = get_identifier (namebuffer);
5891            decl_result = IDENTIFIER_CLASS_VALUE (name);
5892          }
5893       } while (!decl_result && separator);
5894     }
5895   return decl_result;
5896 }
5897
5898 static tree
5899 qualify_and_find (tree class_type, tree package, tree name)
5900 {
5901   tree new_qualified = merge_qualified_name (package, name);
5902   tree new_class_decl;
5903
5904   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5905     load_class (new_qualified, 0);
5906   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5907     {
5908       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5909           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5910         load_class (new_qualified, 0);
5911       TYPE_NAME (class_type) = new_qualified;
5912       return IDENTIFIER_CLASS_VALUE (new_qualified);
5913     }
5914   return NULL_TREE;
5915 }
5916
5917 /* Resolve NAME and lay it out (if not done and if not the current
5918    parsed class). Return a decl node. This function is meant to be
5919    called when type resolution is necessary during the walk pass.  */
5920
5921 static tree
5922 resolve_and_layout (tree something, tree cl)
5923 {
5924   tree decl, decl_type;
5925
5926   /* Don't do that on the current class */
5927   if (something == current_class)
5928     return TYPE_NAME (current_class);
5929
5930   /* Don't do anything for void and other primitive types */
5931   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5932     return NULL_TREE;
5933
5934   /* Pointer types can be reall pointer types or fake pointers. When
5935      finding a real pointer, recheck for primitive types */
5936   if (TREE_CODE (something) == POINTER_TYPE)
5937     {
5938       if (TREE_TYPE (something))
5939         {
5940           something = TREE_TYPE (something);
5941           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5942             return NULL_TREE;
5943         }
5944       else
5945         something = TYPE_NAME (something);
5946     }
5947
5948   /* Don't do anything for arrays of primitive types */
5949   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5950       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5951     return NULL_TREE;
5952
5953   /* Something might be a WFL */
5954   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5955     something = EXPR_WFL_NODE (something);
5956
5957   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5958      TYPE_DECL or a real TYPE */
5959   else if (TREE_CODE (something) != IDENTIFIER_NODE)
5960     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5961             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5962
5963   if (!(decl = resolve_no_layout (something, cl)))
5964     return NULL_TREE;
5965
5966   /* Resolve and layout if necessary */
5967   decl_type = TREE_TYPE (decl);
5968   layout_class_methods (decl_type);
5969   /* Check methods */
5970   if (CLASS_FROM_SOURCE_P (decl_type))
5971     java_check_methods (decl);
5972   /* Layout the type if necessary */
5973   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5974     safe_layout_class (decl_type);
5975
5976   return decl;
5977 }
5978
5979 /* Resolve a class, returns its decl but doesn't perform any
5980    layout. The current parsing context is saved and restored */
5981
5982 static tree
5983 resolve_no_layout (tree name, tree cl)
5984 {
5985   tree ptr, decl;
5986   BUILD_PTR_FROM_NAME (ptr, name);
5987   java_parser_context_save_global ();
5988   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5989   java_parser_context_restore_global ();
5990
5991   return decl;
5992 }
5993
5994 /* Called when reporting errors. Skip the '[]'s in a complex array
5995    type description that failed to be resolved. purify_type_name can't
5996    use an identifier tree.  */
5997
5998 static const char *
5999 purify_type_name (const char *name)
6000 {
6001   int len = strlen (name);
6002   int bracket_found;
6003
6004   STRING_STRIP_BRACKETS (name, len, bracket_found);
6005   if (bracket_found)
6006     {
6007       char *stripped_name = xmemdup (name, len, len+1);
6008       stripped_name [len] = '\0';
6009       return stripped_name;
6010     }
6011   return name;
6012 }
6013
6014 /* The type CURRENT refers to can't be found. We print error messages.  */
6015
6016 static void
6017 complete_class_report_errors (jdep *dep)
6018 {
6019   const char *name;
6020
6021   if (!JDEP_WFL (dep))
6022     return;
6023
6024   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6025   switch (JDEP_KIND (dep))
6026     {
6027     case JDEP_SUPER:
6028       parse_error_context
6029         (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
6030          purify_type_name (name),
6031          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6032       break;
6033     case JDEP_FIELD:
6034       parse_error_context
6035         (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
6036          purify_type_name (name),
6037          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6038       break;
6039     case JDEP_METHOD:           /* Covers arguments */
6040       parse_error_context
6041         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
6042          purify_type_name (name),
6043          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6044          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6045       break;
6046     case JDEP_METHOD_RETURN:    /* Covers return type */
6047       parse_error_context
6048         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
6049          purify_type_name (name),
6050          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6051       break;
6052     case JDEP_INTERFACE:
6053       parse_error_context
6054         (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
6055          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6056          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6057          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6058       break;
6059     case JDEP_VARIABLE:
6060       parse_error_context
6061         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
6062          purify_type_name (IDENTIFIER_POINTER
6063                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6064          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6065       break;
6066     case JDEP_EXCEPTION:        /* As specified by `throws' */
6067       parse_error_context
6068           (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6069          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6070       break;
6071     default:
6072       /* Fix for -Wall. Just break doing nothing. The error will be
6073          caught later */
6074       break;
6075     }
6076 }
6077
6078 /* Return a static string containing the DECL prototype string. If
6079    DECL is a constructor, use the class name instead of the form
6080    <init> */
6081
6082 static const char *
6083 get_printable_method_name (tree decl)
6084 {
6085   const char *to_return;
6086   tree name = NULL_TREE;
6087
6088   if (DECL_CONSTRUCTOR_P (decl))
6089     {
6090       name = DECL_NAME (decl);
6091       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6092     }
6093
6094   to_return = lang_printable_name (decl, 0);
6095   if (DECL_CONSTRUCTOR_P (decl))
6096     DECL_NAME (decl) = name;
6097
6098   return to_return;
6099 }
6100
6101 /* Track method being redefined inside the same class. As a side
6102    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6103    function it's a FWL, so we can track errors more accurately.)  */
6104
6105 static int
6106 check_method_redefinition (tree class, tree method)
6107 {
6108   tree redef, sig;
6109
6110   /* There's no need to verify <clinit> and finit$ and instinit$ */
6111   if (DECL_CLINIT_P (method)
6112       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6113     return 0;
6114
6115   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6116   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6117     {
6118       if (redef == method)
6119         break;
6120       if (DECL_NAME (redef) == DECL_NAME (method)
6121           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6122           && !DECL_ARTIFICIAL (method))
6123         {
6124           parse_error_context
6125             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6126              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6127              get_printable_method_name (redef));
6128           return 1;
6129         }
6130     }
6131   return 0;
6132 }
6133
6134 /* Return 1 if check went ok, 0 otherwise.  */
6135 static int
6136 check_abstract_method_definitions (int do_interface, tree class_decl,
6137                                    tree type)
6138 {
6139   tree class = TREE_TYPE (class_decl);
6140   tree method, end_type;
6141   int ok = 1;
6142
6143   end_type = (do_interface ? object_type_node : type);
6144   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6145     {
6146       tree other_super, other_method, method_sig, method_name;
6147       int found = 0;
6148       int end_type_reached = 0;
6149
6150       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6151         continue;
6152
6153       /* Now verify that somewhere in between TYPE and CLASS,
6154          abstract method METHOD gets a non abstract definition
6155          that is inherited by CLASS.  */
6156
6157       method_sig = build_java_signature (TREE_TYPE (method));
6158       method_name = DECL_NAME (method);
6159       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6160         method_name = EXPR_WFL_NODE (method_name);
6161
6162       other_super = class;
6163       do {
6164         if (other_super == end_type)
6165           end_type_reached = 1;
6166
6167         /* Method search */
6168         for (other_method = TYPE_METHODS (other_super); other_method;
6169             other_method = TREE_CHAIN (other_method))
6170           {
6171             tree s = build_java_signature (TREE_TYPE (other_method));
6172             tree other_name = DECL_NAME (other_method);
6173
6174             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6175               other_name = EXPR_WFL_NODE (other_name);
6176             if (!DECL_CLINIT_P (other_method)
6177                 && !DECL_CONSTRUCTOR_P (other_method)
6178                 && method_name == other_name
6179                 && method_sig == s
6180                 && !METHOD_ABSTRACT (other_method))
6181              {
6182                found = 1;
6183                break;
6184              }
6185           }
6186         other_super = CLASSTYPE_SUPER (other_super);
6187       } while (!end_type_reached);
6188
6189       /* Report that abstract METHOD didn't find an implementation
6190          that CLASS can use. */
6191       if (!found)
6192         {
6193           char *t = xstrdup (lang_printable_name
6194                             (TREE_TYPE (TREE_TYPE (method)), 0));
6195           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6196
6197           parse_error_context
6198             (lookup_cl (class_decl),
6199              "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",
6200              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6201              t, lang_printable_name (method, 0),
6202              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6203               "interface" : "class"),
6204              IDENTIFIER_POINTER (ccn),
6205              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6206              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6207           ok = 0;
6208           free (t);
6209         }
6210     }
6211
6212   if (ok && do_interface)
6213     {
6214       /* Check for implemented interfaces. */
6215       int i;
6216       tree vector = TYPE_BINFO_BASETYPES (type);
6217       for (i = 1; ok && vector && i < TREE_VEC_LENGTH (vector); i++)
6218         {
6219           tree super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6220           ok = check_abstract_method_definitions (1, class_decl, super);
6221         }
6222     }
6223
6224   return ok;
6225 }
6226
6227 /* Check that CLASS_DECL somehow implements all inherited abstract
6228    methods.  */
6229
6230 static void
6231 java_check_abstract_method_definitions (tree class_decl)
6232 {
6233   tree class = TREE_TYPE (class_decl);
6234   tree super, vector;
6235   int i;
6236
6237   if (CLASS_ABSTRACT (class_decl))
6238     return;
6239
6240   /* Check for inherited types */
6241   super = class;
6242   do {
6243     super = CLASSTYPE_SUPER (super);
6244     check_abstract_method_definitions (0, class_decl, super);
6245   } while (super != object_type_node);
6246
6247   /* Check for implemented interfaces. */
6248   vector = TYPE_BINFO_BASETYPES (class);
6249   for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
6250     {
6251       super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6252       check_abstract_method_definitions (1, class_decl, super);
6253     }
6254 }
6255
6256 /* Check all the types method DECL uses and return 1 if all of them
6257    are now complete, 0 otherwise. This is used to check whether its
6258    safe to build a method signature or not.  */
6259
6260 static int
6261 check_method_types_complete (tree decl)
6262 {
6263   tree type = TREE_TYPE (decl);
6264   tree args;
6265
6266   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6267     return 0;
6268
6269   args = TYPE_ARG_TYPES (type);
6270   if (TREE_CODE (type) == METHOD_TYPE)
6271     args = TREE_CHAIN (args);
6272   for (; args != end_params_node; args = TREE_CHAIN (args))
6273     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6274       return 0;
6275
6276   return 1;
6277 }
6278
6279 /* Visible interface to check methods contained in CLASS_DECL */
6280
6281 void
6282 java_check_methods (tree class_decl)
6283 {
6284   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6285     return;
6286
6287   if (CLASS_INTERFACE (class_decl))
6288     java_check_abstract_methods (class_decl);
6289   else
6290     java_check_regular_methods (class_decl);
6291
6292   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6293 }
6294
6295 /* Like not_accessible_p, but doesn't refer to the current class at
6296    all.  */
6297 static bool
6298 hack_is_accessible_p (tree member, tree from_where)
6299 {
6300   int flags = get_access_flags_from_decl (member);
6301
6302   if (from_where == DECL_CONTEXT (member)
6303       || (flags & ACC_PUBLIC))
6304     return true;
6305
6306   if ((flags & ACC_PROTECTED))
6307     {
6308       if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6309         return true;
6310     }
6311
6312   if ((flags & ACC_PRIVATE))
6313     return false;
6314
6315   /* Package private, or protected.  */
6316   return in_same_package (TYPE_NAME (from_where),
6317                           TYPE_NAME (DECL_CONTEXT (member)));
6318 }
6319
6320 /* Check all the methods of CLASS_DECL. Methods are first completed
6321    then checked according to regular method existence rules.  If no
6322    constructor for CLASS_DECL were encountered, then build its
6323    declaration.  */
6324 static void
6325 java_check_regular_methods (tree class_decl)
6326 {
6327   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6328   tree method;
6329   tree class = TREE_TYPE (class_decl);
6330   tree found = NULL_TREE;
6331   tree mthrows;
6332
6333   /* It is not necessary to check methods defined in java.lang.Object */
6334   if (class == object_type_node)
6335     return;
6336
6337   if (!TYPE_NVIRTUALS (class))
6338     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6339
6340   /* Should take interfaces into account. FIXME */
6341   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6342     {
6343       tree sig;
6344       tree method_wfl = DECL_FUNCTION_WFL (method);
6345       int aflags;
6346
6347       /* Check for redefinitions */
6348       if (check_method_redefinition (class, method))
6349         continue;
6350
6351       /* We verify things thrown by the method.  They must inherit from
6352          java.lang.Throwable.  */
6353       for (mthrows = DECL_FUNCTION_THROWS (method);
6354            mthrows; mthrows = TREE_CHAIN (mthrows))
6355         {
6356           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6357             parse_error_context
6358               (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6359                IDENTIFIER_POINTER
6360                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6361         }
6362
6363       /* If we see one constructor a mark so we don't generate the
6364          default one.  Also skip other verifications: constructors
6365          can't be inherited hence hidden or overridden.  */
6366       if (DECL_CONSTRUCTOR_P (method))
6367         {
6368           saw_constructor = 1;
6369           continue;
6370         }
6371
6372       sig = build_java_argument_signature (TREE_TYPE (method));
6373       found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6374                                               SEARCH_SUPER | SEARCH_INTERFACE);
6375
6376       /* Inner class can't declare static methods */
6377       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6378         {
6379           char *t = xstrdup (lang_printable_name (class, 0));
6380           parse_error_context
6381             (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6382              lang_printable_name (method, 0), t);
6383           free (t);
6384         }
6385
6386       /* Nothing overrides or it's a private method. */
6387       if (!found)
6388         continue;
6389       if (METHOD_PRIVATE (found))
6390         {
6391           found = NULL_TREE;
6392           continue;
6393         }
6394
6395       /* If `found' is declared in an interface, make sure the
6396          modifier matches. */
6397       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6398           && clinit_identifier_node != DECL_NAME (found)
6399           && !METHOD_PUBLIC (method))
6400         {
6401           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6402           parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6403                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6404                                lang_printable_name (method, 0),
6405                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6406         }
6407
6408       /* Can't override a method with the same name and different return
6409          types. */
6410       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6411         {
6412           char *t = xstrdup
6413             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6414           parse_error_context
6415             (method_wfl,
6416              "Method `%s' was defined with return type `%s' in class `%s'",
6417              lang_printable_name (found, 0), t,
6418              IDENTIFIER_POINTER
6419                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6420           free (t);
6421         }
6422
6423       aflags = get_access_flags_from_decl (found);
6424
6425       /* Can't override final. Can't override static. */
6426       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6427         {
6428           /* Static *can* override static */
6429           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6430             continue;
6431           parse_error_context
6432             (method_wfl,
6433              "%s methods can't be overridden. Method `%s' is %s in class `%s'",
6434              (METHOD_FINAL (found) ? "Final" : "Static"),
6435              lang_printable_name (found, 0),
6436              (METHOD_FINAL (found) ? "final" : "static"),
6437              IDENTIFIER_POINTER
6438                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6439           continue;
6440         }
6441
6442       /* Static method can't override instance method. */
6443       if (METHOD_STATIC (method))
6444         {
6445           parse_error_context
6446             (method_wfl,
6447              "Instance methods can't be overridden by a static method. Method `%s' is an instance method in class `%s'",
6448              lang_printable_name (found, 0),
6449              IDENTIFIER_POINTER
6450                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6451           continue;
6452         }
6453
6454       /* - Overriding/hiding public must be public
6455          - Overriding/hiding protected must be protected or public
6456          - If the overridden or hidden method has default (package)
6457            access, then the overriding or hiding method must not be
6458            private; otherwise, a compile-time error occurs.  If
6459            `found' belongs to an interface, things have been already
6460            taken care of.  */
6461       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6462           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6463               || (METHOD_PROTECTED (found)
6464                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6465               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6466                   && METHOD_PRIVATE (method))))
6467         {
6468           parse_error_context
6469             (method_wfl,
6470              "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6471              (METHOD_PUBLIC (method) ? "public" :
6472               (METHOD_PRIVATE (method) ? "private" : "protected")),
6473              IDENTIFIER_POINTER (DECL_NAME
6474                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6475           continue;
6476         }
6477
6478       /* Check this method against all the other implementations it
6479          overrides.  Here we only check the class hierarchy; the rest
6480          of the checking is done later.  If this method is just a
6481          Miranda method, we can skip the check.  */
6482       if (! METHOD_INVISIBLE (method))
6483         check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6484     }
6485
6486   /* The above throws clause check only looked at superclasses.  Now
6487      we must also make sure that all methods declared in interfaces
6488      have compatible throws clauses.  FIXME: there are more efficient
6489      ways to organize this checking; we should implement one.  */
6490   check_interface_throws_clauses (class, class);
6491
6492   if (!TYPE_NVIRTUALS (class))
6493     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6494
6495   /* Search for inherited abstract method not yet implemented in this
6496      class.  */
6497   java_check_abstract_method_definitions (class_decl);
6498
6499   if (!saw_constructor)
6500     abort ();
6501 }
6502
6503 /* Check to make sure that all the methods in all the interfaces
6504    implemented by CLASS_DECL are compatible with the concrete
6505    implementations available in CHECK_CLASS_DECL.  */
6506 static void
6507 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6508 {
6509   for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6510     {
6511       tree bases;
6512       int iface_len;
6513       int i;
6514
6515       if (! CLASS_LOADED_P (class_decl))
6516         {
6517           if (CLASS_FROM_SOURCE_P (class_decl))
6518             safe_layout_class (class_decl);
6519           else
6520             load_class (class_decl, 1);
6521         }
6522
6523       bases = TYPE_BINFO_BASETYPES (class_decl);
6524       iface_len = TREE_VEC_LENGTH (bases) - 1;
6525       for (i = iface_len; i > 0; --i)
6526         {
6527           tree interface = BINFO_TYPE (TREE_VEC_ELT (bases, i));
6528           tree iface_method;
6529
6530           for (iface_method = TYPE_METHODS (interface);
6531                iface_method != NULL_TREE;
6532                iface_method = TREE_CHAIN (iface_method))
6533             {
6534               tree sig, method;
6535
6536               /* First look for a concrete method implemented or
6537                  inherited by this class.  No need to search
6538                  interfaces here, since we're already looking through
6539                  all of them.  */
6540               sig = build_java_argument_signature (TREE_TYPE (iface_method));
6541               method
6542                 = lookup_argument_method_generic (check_class_decl,
6543                                                   DECL_NAME (iface_method),
6544                                                   sig, SEARCH_VISIBLE);
6545               /* If we don't find an implementation, that is ok.  Any
6546                  potential errors from that are diagnosed elsewhere.
6547                  Also, multiple inheritance with conflicting throws
6548                  clauses is fine in the absence of a concrete
6549                  implementation.  */
6550               if (method != NULL_TREE && !METHOD_ABSTRACT (method)
6551                   && !METHOD_INVISIBLE (iface_method))
6552                 {
6553                   tree method_wfl = DECL_FUNCTION_WFL (method);
6554                   check_throws_clauses (method, method_wfl, iface_method);
6555                 }
6556             }
6557
6558           /* Now check superinterfaces.  */
6559           check_interface_throws_clauses (check_class_decl, interface);
6560         }
6561     }
6562 }
6563
6564 /* Check throws clauses of a method against the clauses of all the
6565    methods it overrides.  We do this by searching up the class
6566    hierarchy, examining all matching accessible methods.  */
6567 static void
6568 check_concrete_throws_clauses (tree class, tree self_method,
6569                                tree name, tree signature)
6570 {
6571   tree method = lookup_argument_method_generic (class, name, signature,
6572                                                 SEARCH_SUPER | SEARCH_VISIBLE);
6573   while (method != NULL_TREE)
6574     {
6575       if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6576         check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6577                               method);
6578
6579       method = lookup_argument_method_generic (DECL_CONTEXT (method),
6580                                                name, signature,
6581                                                SEARCH_SUPER | SEARCH_VISIBLE);
6582     }
6583 }
6584
6585 /* Generate an error if the `throws' clause of METHOD (if any) is
6586    incompatible with the `throws' clause of FOUND (if any).  */
6587 static void
6588 check_throws_clauses (tree method, tree method_wfl, tree found)
6589 {
6590   tree mthrows;
6591
6592   /* Can't check these things with class loaded from bytecode. FIXME */
6593   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6594     return;
6595
6596   for (mthrows = DECL_FUNCTION_THROWS (method);
6597        mthrows; mthrows = TREE_CHAIN (mthrows))
6598     {
6599       tree fthrows;
6600
6601       /* We don't verify unchecked expressions */
6602       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6603         continue;
6604       /* Checked expression must be compatible */
6605       for (fthrows = DECL_FUNCTION_THROWS (found);
6606            fthrows; fthrows = TREE_CHAIN (fthrows))
6607         {
6608           if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6609             break;
6610         }
6611       if (!fthrows)
6612         {
6613           parse_error_context
6614             (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'",
6615              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6616              lang_printable_name (found, 0),
6617              IDENTIFIER_POINTER
6618              (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6619         }
6620     }
6621 }
6622
6623 /* Check abstract method of interface INTERFACE */
6624 static void
6625 java_check_abstract_methods (tree interface_decl)
6626 {
6627   int i, n;
6628   tree method, basetype_vec, found;
6629   tree interface = TREE_TYPE (interface_decl);
6630
6631   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6632     {
6633       /* 2- Check for double definition inside the defining interface */
6634       if (check_method_redefinition (interface, method))
6635         continue;
6636
6637       /* 3- Overriding is OK as far as we preserve the return type.  */
6638       found = lookup_java_interface_method2 (interface, method);
6639       if (found)
6640         {
6641           char *t;
6642           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6643           parse_error_context
6644             (DECL_FUNCTION_WFL (found),
6645              "Method `%s' was defined with return type `%s' in class `%s'",
6646              lang_printable_name (found, 0), t,
6647              IDENTIFIER_POINTER
6648                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6649           free (t);
6650           continue;
6651         }
6652     }
6653
6654   /* 4- Inherited methods can't differ by their returned types */
6655   if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6656     return;
6657   n = TREE_VEC_LENGTH (basetype_vec);
6658   for (i = 0; i < n; i++)
6659     {
6660       tree sub_interface_method, sub_interface;
6661       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6662       if (!vec_elt)
6663         continue;
6664       sub_interface = BINFO_TYPE (vec_elt);
6665       for (sub_interface_method = TYPE_METHODS (sub_interface);
6666            sub_interface_method;
6667            sub_interface_method = TREE_CHAIN (sub_interface_method))
6668         {
6669           found = lookup_java_interface_method2 (interface,
6670                                                  sub_interface_method);
6671           if (found && (found != sub_interface_method))
6672             {
6673               parse_error_context
6674                 (lookup_cl (sub_interface_method),
6675                  "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6676                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6677                  lang_printable_name (found, 0),
6678                  IDENTIFIER_POINTER
6679                    (DECL_NAME (TYPE_NAME
6680                                (DECL_CONTEXT (sub_interface_method)))),
6681                  IDENTIFIER_POINTER
6682                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6683             }
6684         }
6685     }
6686 }
6687
6688 /* Lookup methods in interfaces using their name and partial
6689    signature. Return a matching method only if their types differ.  */
6690
6691 static tree
6692 lookup_java_interface_method2 (tree class, tree method_decl)
6693 {
6694   int i, n;
6695   tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6696
6697   if (!basetype_vec)
6698     return NULL_TREE;
6699
6700   n = TREE_VEC_LENGTH (basetype_vec);
6701   for (i = 0; i < n; i++)
6702     {
6703       tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6704       if ((BINFO_TYPE (vec_elt) != object_type_node)
6705           && (to_return =
6706               lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6707         return to_return;
6708     }
6709   for (i = 0; i < n; i++)
6710     {
6711       to_return = lookup_java_interface_method2
6712         (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6713       if (to_return)
6714         return to_return;
6715     }
6716
6717   return NULL_TREE;
6718 }
6719
6720 /* Lookup method using their name and partial signature. Return a
6721    matching method only if their types differ.  */
6722
6723 static tree
6724 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6725 {
6726   tree method, method_signature, method_name, method_type, name;
6727
6728   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6729   name = DECL_NAME (method_decl);
6730   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6731                  EXPR_WFL_NODE (name) : name);
6732   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6733
6734   while (clas != NULL_TREE)
6735     {
6736       for (method = TYPE_METHODS (clas);
6737            method != NULL_TREE;  method = TREE_CHAIN (method))
6738         {
6739           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6740           tree name = DECL_NAME (method);
6741           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6742                EXPR_WFL_NODE (name) : name) == method_name
6743               && method_sig == method_signature
6744               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6745             return method;
6746         }
6747       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6748     }
6749   return NULL_TREE;
6750 }
6751
6752 /* Return the line that matches DECL line number, and try its best to
6753    position the column number. Used during error reports.  */
6754
6755 static GTY(()) tree cl_v;
6756 static tree
6757 lookup_cl (tree decl)
6758 {
6759   char *line, *found;
6760
6761   if (!decl)
6762     return NULL_TREE;
6763
6764   if (cl_v == NULL_TREE)
6765     {
6766       cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6767     }
6768
6769   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6770   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6771
6772   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6773                             EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6774
6775   found = strstr ((const char *)line,
6776                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6777   if (found)
6778     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6779
6780   return cl_v;
6781 }
6782
6783 /* Look for a simple name in the single-type import list */
6784
6785 static tree
6786 find_name_in_single_imports (tree name)
6787 {
6788   tree node;
6789
6790   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6791     if (TREE_VALUE (node) == name)
6792       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6793
6794   return NULL_TREE;
6795 }
6796
6797 /* Process all single-type import. */
6798
6799 static int
6800 process_imports (void)
6801 {
6802   tree import;
6803   int error_found;
6804
6805   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6806     {
6807       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6808       char *original_name;
6809
6810       original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6811                                IDENTIFIER_LENGTH (to_be_found),
6812                                IDENTIFIER_LENGTH (to_be_found) + 1);
6813
6814       /* Don't load twice something already defined. */
6815       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6816         continue;
6817
6818       while (1)
6819         {
6820           tree left;
6821
6822           QUALIFIED_P (to_be_found) = 1;
6823           load_class (to_be_found, 0);
6824           error_found =
6825             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true, NULL_TREE);
6826
6827           /* We found it, we can bail out */
6828           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6829             {
6830               check_deprecation (TREE_PURPOSE (import),
6831                                  IDENTIFIER_CLASS_VALUE (to_be_found));
6832               break;
6833             }
6834
6835           /* We haven't found it. Maybe we're trying to access an
6836              inner class.  The only way for us to know is to try again
6837              after having dropped a qualifier. If we can't break it further,
6838              we have an error. */
6839           if (breakdown_qualified (&left, NULL, to_be_found))
6840             break;
6841
6842           to_be_found = left;
6843         }
6844       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6845         {
6846           parse_error_context (TREE_PURPOSE (import),
6847                                "Class or interface `%s' not found in import",
6848                                original_name);
6849           error_found = 1;
6850         }
6851
6852       free (original_name);
6853       if (error_found)
6854         return 1;
6855     }
6856   return 0;
6857 }
6858
6859 /* Possibly find and mark a class imported by a single-type import
6860    statement.  */
6861
6862 static void
6863 find_in_imports (tree enclosing_type, tree class_type)
6864 {
6865   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6866                  ctxp->import_list);
6867   while (import)
6868     {
6869       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6870         {
6871           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6872           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6873           return;
6874         }
6875       import = TREE_CHAIN (import);
6876     }
6877 }
6878
6879 static int
6880 note_possible_classname (const char *name, int len)
6881 {
6882   tree node;
6883   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6884     len = len - 5;
6885   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6886     len = len - 6;
6887   else
6888     return 0;
6889   node = ident_subst (name, len, "", '/', '.', "");
6890   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6891   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6892   return 1;
6893 }
6894
6895 /* Read a import directory, gathering potential match for further type
6896    references. Indifferently reads a filesystem or a ZIP archive
6897    directory.  */
6898
6899 static void
6900 read_import_dir (tree wfl)
6901 {
6902   tree package_id = EXPR_WFL_NODE (wfl);
6903   const char *package_name = IDENTIFIER_POINTER (package_id);
6904   int package_length = IDENTIFIER_LENGTH (package_id);
6905   DIR *dirp = NULL;
6906   JCF *saved_jcf = current_jcf;
6907
6908   int found = 0;
6909   int k;
6910   void *entry;
6911   struct buffer filename[1];
6912
6913   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6914     return;
6915   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6916
6917   BUFFER_INIT (filename);
6918   buffer_grow (filename, package_length + 100);
6919
6920   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6921     {
6922       const char *entry_name = jcf_path_name (entry);
6923       int entry_length = strlen (entry_name);
6924       if (jcf_path_is_zipfile (entry))
6925         {
6926           ZipFile *zipf;
6927           buffer_grow (filename, entry_length);
6928           memcpy (filename->data, entry_name, entry_length - 1);
6929           filename->data[entry_length-1] = '\0';
6930           zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6931           if (zipf == NULL)
6932             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6933           else
6934             {
6935               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6936               BUFFER_RESET (filename);
6937               for (k = 0; k < package_length; k++)
6938                 {
6939                   char ch = package_name[k];
6940                   *filename->ptr++ = ch == '.' ? '/' : ch;
6941                 }
6942               *filename->ptr++ = '/';
6943
6944               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
6945                 {
6946                   const char *current_entry = ZIPDIR_FILENAME (zipd);
6947                   int current_entry_len = zipd->filename_length;
6948
6949                   if (current_entry_len >= BUFFER_LENGTH (filename)
6950                       && strncmp (filename->data, current_entry,
6951                                   BUFFER_LENGTH (filename)) != 0)
6952                     continue;
6953                   found |= note_possible_classname (current_entry,
6954                                                     current_entry_len);
6955                 }
6956             }
6957         }
6958       else
6959         {
6960           BUFFER_RESET (filename);
6961           buffer_grow (filename, entry_length + package_length + 4);
6962           strcpy (filename->data, entry_name);
6963           filename->ptr = filename->data + entry_length;
6964           for (k = 0; k < package_length; k++)
6965             {
6966               char ch = package_name[k];
6967               *filename->ptr++ = ch == '.' ? '/' : ch;
6968             }
6969           *filename->ptr = '\0';
6970
6971           dirp = opendir (filename->data);
6972           if (dirp == NULL)
6973             continue;
6974           *filename->ptr++ = '/';
6975           for (;;)
6976             {
6977               int len;
6978               const char *d_name;
6979               struct dirent *direntp = readdir (dirp);
6980               if (!direntp)
6981                 break;
6982               d_name = direntp->d_name;
6983               len = strlen (direntp->d_name);
6984               buffer_grow (filename, len+1);
6985               strcpy (filename->ptr, d_name);
6986               found |= note_possible_classname (filename->data + entry_length,
6987                                                 package_length+len+1);
6988             }
6989           if (dirp)
6990             closedir (dirp);
6991         }
6992     }
6993
6994   free (filename->data);
6995
6996   /* Here we should have a unified way of retrieving an entry, to be
6997      indexed. */
6998   if (!found)
6999     {
7000       static int first = 1;
7001       if (first)
7002         {
7003           error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
7004           java_error_count++;
7005           first = 0;
7006         }
7007       else
7008         parse_error_context (wfl, "Package `%s' not found in import",
7009                              package_name);
7010       current_jcf = saved_jcf;
7011       return;
7012     }
7013   current_jcf = saved_jcf;
7014 }
7015
7016 /* Possibly find a type in the import on demands specified
7017    types. Returns 1 if an error occurred, 0 otherwise. Run through the
7018    entire list, to detected potential double definitions.  */
7019
7020 static int
7021 find_in_imports_on_demand (tree enclosing_type, tree class_type)
7022 {
7023   tree class_type_name = TYPE_NAME (class_type);
7024   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
7025                   ctxp->import_demand_list);
7026   tree cl = NULL_TREE;
7027   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
7028   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
7029   tree node;
7030
7031   for (; import; import = TREE_CHAIN (import))
7032     {
7033       int saved_lineno = input_line;
7034       int access_check;
7035       const char *id_name;
7036       tree decl, type_name_copy;
7037
7038       obstack_grow (&temporary_obstack,
7039                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
7040                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
7041       obstack_1grow (&temporary_obstack, '.');
7042       obstack_grow0 (&temporary_obstack,
7043                      IDENTIFIER_POINTER (class_type_name),
7044                      IDENTIFIER_LENGTH (class_type_name));
7045       id_name = obstack_finish (&temporary_obstack);
7046
7047       if (! (node = maybe_get_identifier (id_name)))
7048         continue;
7049
7050       /* Setup lineno so that it refers to the line of the import (in
7051          case we parse a class file and encounter errors */
7052       input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
7053
7054       type_name_copy = TYPE_NAME (class_type);
7055       TYPE_NAME (class_type) = node;
7056       QUALIFIED_P (node) = 1;
7057       decl = IDENTIFIER_CLASS_VALUE (node);
7058       access_check = -1;
7059       /* If there is no DECL set for the class or if the class isn't
7060          loaded and not seen in source yet, then load */
7061       if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
7062                     && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
7063         {
7064           load_class (node, 0);
7065           decl = IDENTIFIER_CLASS_VALUE (node);
7066         }
7067       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7068         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7069                                                false, NULL_TREE);
7070       else
7071         /* 6.6.1: Inner classes are subject to member access rules. */
7072         access_check = 0;
7073
7074       input_line = saved_lineno;
7075
7076       /* If the loaded class is not accessible or couldn't be loaded,
7077          we restore the original TYPE_NAME and process the next
7078          import. */
7079       if (access_check || !decl)
7080         {
7081           TYPE_NAME (class_type) = type_name_copy;
7082           continue;
7083         }
7084
7085       /* If the loaded class is accessible, we keep a tab on it to
7086          detect and report multiple inclusions. */
7087       if (IS_A_CLASSFILE_NAME (node))
7088         {
7089           if (seen_once < 0)
7090             {
7091               cl = TREE_PURPOSE (import);
7092               seen_once = 1;
7093             }
7094           else if (seen_once >= 0)
7095             {
7096               tree location = (cl ? cl : TREE_PURPOSE (import));
7097               tree package = (cl ? EXPR_WFL_NODE (cl) :
7098                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
7099               seen_once++;
7100               parse_error_context
7101                 (location,
7102                  "Type `%s' also potentially defined in package `%s'",
7103                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7104                  IDENTIFIER_POINTER (package));
7105             }
7106         }
7107       to_return = access_check;
7108     }
7109
7110   if (seen_once == 1)
7111     return to_return;
7112   else
7113     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7114 }
7115
7116 /* Add package NAME to the list of packages encountered so far. To
7117    speed up class lookup in do_resolve_class, we make sure a
7118    particular package is added only once.  */
7119
7120 static void
7121 register_package (tree name)
7122 {
7123   static htab_t pht;
7124   void **e;
7125
7126   if (pht == NULL)
7127     pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
7128
7129   e = htab_find_slot (pht, name, INSERT);
7130   if (*e == NULL)
7131     {
7132       package_list = chainon (package_list, build_tree_list (name, NULL));
7133       *e = name;
7134     }
7135 }
7136
7137 static tree
7138 resolve_package (tree pkg, tree *next, tree *type_name)
7139 {
7140   tree current;
7141   tree decl = NULL_TREE;
7142   *type_name = NULL_TREE;
7143
7144   /* The trick is to determine when the package name stops and were
7145      the name of something contained in the package starts. Then we
7146      return a fully qualified name of what we want to get. */
7147
7148   *next = EXPR_WFL_QUALIFICATION (pkg);
7149
7150   /* Try to progressively construct a type name */
7151   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7152     for (current = EXPR_WFL_QUALIFICATION (pkg);
7153          current; current = TREE_CHAIN (current))
7154       {
7155         /* If we don't have what we're expecting, exit now. TYPE_NAME
7156            will be null and the error caught later. */
7157         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7158           break;
7159         *type_name =
7160           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7161         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7162           {
7163             /* resolve_package should be used in a loop, hence we
7164                point at this one to naturally process the next one at
7165                the next iteration. */
7166             *next = current;
7167             break;
7168           }
7169       }
7170   return decl;
7171 }
7172
7173
7174 /* Check accessibility of inner classes according to member access rules.
7175    DECL is the inner class, ENCLOSING_DECL is the class from which the
7176    access is being attempted. */
7177
7178 static void
7179 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7180 {
7181   const char *access;
7182   tree enclosing_decl_type;
7183
7184   /* We don't issue an error message when CL is null. CL can be null
7185      as a result of processing a JDEP crafted by source_start_java_method
7186      for the purpose of patching its parm decl. But the error would
7187      have been already trapped when fixing the method's signature.
7188      DECL can also be NULL in case of earlier errors. */
7189   if (!decl || !cl)
7190     return;
7191
7192   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7193
7194   if (CLASS_PRIVATE (decl))
7195     {
7196       /* Access is permitted only within the body of the top-level
7197          class in which DECL is declared. */
7198       tree top_level = decl;
7199       while (DECL_CONTEXT (top_level))
7200         top_level = DECL_CONTEXT (top_level);
7201       while (DECL_CONTEXT (enclosing_decl))
7202         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7203       if (top_level == enclosing_decl)
7204         return;
7205       access = "private";
7206     }
7207   else if (CLASS_PROTECTED (decl))
7208     {
7209       tree decl_context;
7210       /* Access is permitted from within the same package... */
7211       if (in_same_package (decl, enclosing_decl))
7212         return;
7213
7214       /* ... or from within the body of a subtype of the context in which
7215          DECL is declared. */
7216       decl_context = DECL_CONTEXT (decl);
7217       while (enclosing_decl)
7218         {
7219           if (CLASS_INTERFACE (decl))
7220             {
7221               if (interface_of_p (TREE_TYPE (decl_context),
7222                                   enclosing_decl_type))
7223                 return;
7224             }
7225           else
7226             {
7227               /* Eww. The order of the arguments is different!! */
7228               if (inherits_from_p (enclosing_decl_type,
7229                                    TREE_TYPE (decl_context)))
7230                 return;
7231             }
7232           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7233         }
7234       access = "protected";
7235     }
7236   else if (! CLASS_PUBLIC (decl))
7237     {
7238       /* Access is permitted only from within the same package as DECL. */
7239       if (in_same_package (decl, enclosing_decl))
7240         return;
7241       access = "non-public";
7242     }
7243   else
7244     /* Class is public. */
7245     return;
7246
7247   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7248                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7249                        lang_printable_name (decl, 0), access);
7250 }
7251
7252 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7253    foreign package, it must be PUBLIC. Return 0 if no access
7254    violations were found, 1 otherwise. If VERBOSE is true and an error
7255    was found, it is reported and accounted for.  If CL is NULL then
7256    look it up with THIS_DECL.  */
7257
7258 static int
7259 check_pkg_class_access (tree class_name, tree cl, bool verbose, tree this_decl)
7260 {
7261   tree type;
7262
7263   if (!IDENTIFIER_CLASS_VALUE (class_name))
7264     return 0;
7265
7266   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7267     return 0;
7268
7269   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7270     {
7271       /* Access to a private class within the same package is
7272          allowed. */
7273       tree l, r;
7274       breakdown_qualified (&l, &r, class_name);
7275       if (!QUALIFIED_P (class_name) && !ctxp->package)
7276         /* Both in the empty package. */
7277         return 0;
7278       if (l == ctxp->package)
7279         /* Both in the same package. */
7280         return 0;
7281
7282       if (verbose)
7283         parse_error_context
7284           (cl == NULL ? lookup_cl (this_decl): cl,
7285            "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7286            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7287            IDENTIFIER_POINTER (class_name));
7288       return 1;
7289     }
7290   return 0;
7291 }
7292
7293 /* Local variable declaration. */
7294
7295 static void
7296 declare_local_variables (int modifier, tree type, tree vlist)
7297 {
7298   tree decl, current, saved_type;
7299   tree type_wfl = NULL_TREE;
7300   int must_chain = 0;
7301   int final_p = 0;
7302
7303   /* Push a new block if statements were seen between the last time we
7304      pushed a block and now. Keep a count of blocks to close */
7305   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7306     {
7307       tree b = enter_block ();
7308       BLOCK_IS_IMPLICIT (b) = 1;
7309     }
7310
7311   if (modifier)
7312     {
7313       size_t i;
7314       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7315         if (1 << i & modifier)
7316           break;
7317       if (modifier == ACC_FINAL)
7318         final_p = 1;
7319       else
7320         {
7321           parse_error_context
7322             (ctxp->modifier_ctx [i],
7323              "Only `final' is allowed as a local variables modifier");
7324           return;
7325         }
7326     }
7327
7328   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7329      hold the TYPE value if a new incomplete has to be created (as
7330      opposed to being found already existing and reused). */
7331   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7332
7333   /* If TYPE is fully resolved and we don't have a reference, make one */
7334   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7335
7336   /* Go through all the declared variables */
7337   for (current = vlist, saved_type = type; current;
7338        current = TREE_CHAIN (current), type = saved_type)
7339     {
7340       tree other, real_type;
7341       tree wfl  = TREE_PURPOSE (current);
7342       tree name = EXPR_WFL_NODE (wfl);
7343       tree init = TREE_VALUE (current);
7344
7345       /* Process NAME, as it may specify extra dimension(s) for it */
7346       type = build_array_from_name (type, type_wfl, name, &name);
7347
7348       /* Variable redefinition check */
7349       if ((other = lookup_name_in_blocks (name)))
7350         {
7351           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7352                                        DECL_SOURCE_LINE (other));
7353           continue;
7354         }
7355
7356       /* Type adjustment. We may have just readjusted TYPE because
7357          the variable specified more dimensions. Make sure we have
7358          a reference if we can and don't have one already. */
7359       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7360
7361       real_type = GET_REAL_TYPE (type);
7362       /* Never layout this decl. This will be done when its scope
7363          will be entered */
7364       decl = build_decl (VAR_DECL, name, real_type);
7365       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7366       DECL_FINAL (decl) = final_p;
7367       BLOCK_CHAIN_DECL (decl);
7368
7369       /* If doing xreferencing, replace the line number with the WFL
7370          compound value */
7371       if (flag_emit_xref)
7372         DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7373
7374       /* Don't try to use an INIT statement when an error was found */
7375       if (init && java_error_count)
7376         init = NULL_TREE;
7377
7378       /* Add the initialization function to the current function's code */
7379       if (init)
7380         {
7381           /* Name might have been readjusted */
7382           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7383           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7384           java_method_add_stmt (current_function_decl,
7385                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7386                                                       init));
7387         }
7388
7389       /* Setup dependency the type of the decl */
7390       if (must_chain)
7391         {
7392           jdep *dep;
7393           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7394           dep = CLASSD_LAST (ctxp->classd_list);
7395           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7396         }
7397     }
7398   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7399 }
7400
7401 /* Called during parsing. Build decls from argument list.  */
7402
7403 static void
7404 source_start_java_method (tree fndecl)
7405 {
7406   tree tem;
7407   tree parm_decl;
7408   int i;
7409
7410   if (!fndecl)
7411     return;
7412
7413   current_function_decl = fndecl;
7414
7415   /* New scope for the function */
7416   enter_block ();
7417   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7418        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7419     {
7420       tree type = TREE_VALUE (tem);
7421       tree name = TREE_PURPOSE (tem);
7422
7423       /* If type is incomplete. Create an incomplete decl and ask for
7424          the decl to be patched later */
7425       if (INCOMPLETE_TYPE_P (type))
7426         {
7427           jdep *jdep;
7428           tree real_type = GET_REAL_TYPE (type);
7429           parm_decl = build_decl (PARM_DECL, name, real_type);
7430           type = obtain_incomplete_type (type);
7431           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7432           jdep = CLASSD_LAST (ctxp->classd_list);
7433           JDEP_MISC (jdep) = name;
7434           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7435         }
7436       else
7437         parm_decl = build_decl (PARM_DECL, name, type);
7438
7439       /* Remember if a local variable was declared final (via its
7440          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7441       if (ARG_FINAL_P (tem))
7442         {
7443           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7444           DECL_FINAL (parm_decl) = 1;
7445         }
7446
7447       BLOCK_CHAIN_DECL (parm_decl);
7448     }
7449   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7450   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7451     nreverse (tem);
7452   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7453   DECL_MAX_LOCALS (current_function_decl) = i;
7454 }
7455
7456 /* Called during parsing. Creates an artificial method declaration.  */
7457
7458 static tree
7459 create_artificial_method (tree class, int flags, tree type,
7460                           tree name, tree args)
7461 {
7462   tree mdecl;
7463
7464   java_parser_context_save_global ();
7465   input_line = 0;
7466   mdecl = make_node (FUNCTION_TYPE);
7467   TREE_TYPE (mdecl) = type;
7468   TYPE_ARG_TYPES (mdecl) = args;
7469   mdecl = add_method (class, flags, name, build_java_signature (mdecl));
7470   java_parser_context_restore_global ();
7471   DECL_ARTIFICIAL (mdecl) = 1;
7472   return mdecl;
7473 }
7474
7475 /* Starts the body if an artificial method.  */
7476
7477 static void
7478 start_artificial_method_body (tree mdecl)
7479 {
7480   DECL_SOURCE_LINE (mdecl) = 1;
7481   DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7482   source_start_java_method (mdecl);
7483   enter_block ();
7484 }
7485
7486 static void
7487 end_artificial_method_body (tree mdecl)
7488 {
7489   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7490      It has to be evaluated first. (if mdecl is current_function_decl,
7491      we have an undefined behavior if no temporary variable is used.) */
7492   tree b = exit_block ();
7493   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7494   exit_block ();
7495 }
7496
7497 /* Dump a tree of some kind.  This is a convenience wrapper for the
7498    dump_* functions in tree-dump.c.  */
7499 static void
7500 dump_java_tree (enum tree_dump_index phase, tree t)
7501 {
7502   FILE *stream;
7503   int flags;
7504
7505   stream = dump_begin (phase, &flags);
7506   flags |= TDF_SLIM;
7507   if (stream)
7508     {
7509       dump_node (t, flags, stream);
7510       dump_end (phase, stream);
7511     }
7512 }
7513
7514 /* Terminate a function and expand its body.  */
7515
7516 static void
7517 source_end_java_method (void)
7518 {
7519   tree fndecl = current_function_decl;
7520
7521   if (!fndecl)
7522     return;
7523
7524   java_parser_context_save_global ();
7525   input_line = ctxp->last_ccb_indent1;
7526
7527   /* Turn function bodies with only a NOP expr null, so they don't get
7528      generated at all and we won't get warnings when using the -W
7529      -Wall flags. */
7530   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
7531     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7532
7533   /* We've generated all the trees for this function, and it has been
7534      patched.  Dump it to a file if the user requested it.  */
7535   dump_java_tree (TDI_original, fndecl);
7536
7537   /* Defer expanding the method until cgraph analysis is complete.  */
7538   if (DECL_SAVED_TREE (fndecl))
7539     cgraph_finalize_function (fndecl, false);
7540
7541   current_function_decl = NULL_TREE;
7542   java_parser_context_restore_global ();
7543 }
7544
7545 /* Record EXPR in the current function block. Complements compound
7546    expression second operand if necessary.  */
7547
7548 tree
7549 java_method_add_stmt (tree fndecl, tree expr)
7550 {
7551   if (!GET_CURRENT_BLOCK (fndecl))
7552     return NULL_TREE;
7553   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7554 }
7555
7556 static tree
7557 add_stmt_to_block (tree b, tree type, tree stmt)
7558 {
7559   tree body = BLOCK_EXPR_BODY (b), c;
7560
7561   if (java_error_count)
7562     return body;
7563
7564   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7565     return body;
7566
7567   BLOCK_EXPR_BODY (b) = c;
7568   TREE_SIDE_EFFECTS (c) = 1;
7569   return c;
7570 }
7571
7572 /* Add STMT to EXISTING if possible, otherwise create a new
7573    COMPOUND_EXPR and add STMT to it. */
7574
7575 static tree
7576 add_stmt_to_compound (tree existing, tree type, tree stmt)
7577 {
7578   if (existing)
7579     return build (COMPOUND_EXPR, type, existing, stmt);
7580   else
7581     return stmt;
7582 }
7583
7584 void java_layout_seen_class_methods (void)
7585 {
7586   tree previous_list = all_class_list;
7587   tree end = NULL_TREE;
7588   tree current;
7589
7590   while (1)
7591     {
7592       for (current = previous_list;
7593            current != end; current = TREE_CHAIN (current))
7594         layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
7595
7596       if (previous_list != all_class_list)
7597         {
7598           end = previous_list;
7599           previous_list = all_class_list;
7600         }
7601       else
7602         break;
7603     }
7604 }
7605
7606 static GTY(()) tree stop_reordering;
7607 void
7608 java_reorder_fields (void)
7609 {
7610   tree current;
7611
7612   for (current = gclass_list; current; current = TREE_CHAIN (current))
7613     {
7614       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7615
7616       if (current_class == stop_reordering)
7617         break;
7618
7619       /* Reverse the fields, but leave the dummy field in front.
7620          Fields are already ordered for Object and Class */
7621       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7622           && current_class != class_type_node)
7623       {
7624         /* If the dummy field is there, reverse the right fields and
7625            just layout the type for proper fields offset */
7626         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7627           {
7628             tree fields = TYPE_FIELDS (current_class);
7629             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7630             TYPE_SIZE (current_class) = NULL_TREE;
7631           }
7632         /* We don't have a dummy field, we need to layout the class,
7633            after having reversed the fields */
7634         else
7635           {
7636             TYPE_FIELDS (current_class) =
7637               nreverse (TYPE_FIELDS (current_class));
7638             TYPE_SIZE (current_class) = NULL_TREE;
7639           }
7640       }
7641     }
7642   /* There are cases were gclass_list will be empty. */
7643   if (gclass_list)
7644     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7645 }
7646
7647 /* Layout the methods of all classes loaded in one way or another.
7648    Check methods of source parsed classes. Then reorder the
7649    fields and layout the classes or the type of all source parsed
7650    classes */
7651
7652 void
7653 java_layout_classes (void)
7654 {
7655   tree current;
7656   int save_error_count = java_error_count;
7657
7658   /* Layout the methods of all classes seen so far */
7659   java_layout_seen_class_methods ();
7660   java_parse_abort_on_error ();
7661   all_class_list = NULL_TREE;
7662
7663   /* Then check the methods of all parsed classes */
7664   for (current = gclass_list; current; current = TREE_CHAIN (current))
7665     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7666       java_check_methods (TREE_VALUE (current));
7667   java_parse_abort_on_error ();
7668
7669   for (current = gclass_list; current; current = TREE_CHAIN (current))
7670     {
7671       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7672       layout_class (current_class);
7673
7674       /* Error reported by the caller */
7675       if (java_error_count)
7676         return;
7677     }
7678
7679   /* We might have reloaded classes durign the process of laying out
7680      classes for code generation. We must layout the methods of those
7681      late additions, as constructor checks might use them */
7682   java_layout_seen_class_methods ();
7683   java_parse_abort_on_error ();
7684 }
7685
7686 /* Expand methods in the current set of classes remembered for
7687    generation.  */
7688
7689 static void
7690 java_complete_expand_classes (void)
7691 {
7692   tree current;
7693
7694   do_not_fold = flag_emit_xref;
7695
7696   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7697     if (!INNER_CLASS_DECL_P (current))
7698       java_complete_expand_class (current);
7699 }
7700
7701 /* Expand the methods found in OUTER, starting first by OUTER's inner
7702    classes, if any.  */
7703
7704 static void
7705 java_complete_expand_class (tree outer)
7706 {
7707   tree inner_list;
7708
7709   set_nested_class_simple_name_value (outer, 1); /* Set */
7710
7711   /* We need to go after all inner classes and start expanding them,
7712      starting with most nested ones. We have to do that because nested
7713      classes might add functions to outer classes */
7714
7715   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7716        inner_list; inner_list = TREE_CHAIN (inner_list))
7717     java_complete_expand_class (TREE_PURPOSE (inner_list));
7718
7719   java_complete_expand_methods (outer);
7720   set_nested_class_simple_name_value (outer, 0); /* Reset */
7721 }
7722
7723 /* Expand methods registered in CLASS_DECL. The general idea is that
7724    we expand regular methods first. This allows us get an estimate on
7725    how outer context local alias fields are really used so we can add
7726    to the constructor just enough code to initialize them properly (it
7727    also lets us generate finit$ correctly.) Then we expand the
7728    constructors and then <clinit>.  */
7729
7730 static void
7731 java_complete_expand_methods (tree class_decl)
7732 {
7733   tree clinit, decl, first_decl;
7734
7735   output_class = current_class = TREE_TYPE (class_decl);
7736
7737   /* Pre-expand <clinit> to figure whether we really need it or
7738      not. If we do need it, we pre-expand the static fields so they're
7739      ready to be used somewhere else. <clinit> will be fully expanded
7740      after we processed the constructors. */
7741   first_decl = TYPE_METHODS (current_class);
7742   clinit = maybe_generate_pre_expand_clinit (current_class);
7743
7744   /* Then generate finit$ (if we need to) because constructors will
7745    try to use it.*/
7746   if (TYPE_FINIT_STMT_LIST (current_class))
7747     java_complete_expand_method (generate_finit (current_class));
7748
7749   /* Then generate instinit$ (if we need to) because constructors will
7750      try to use it. */
7751   if (TYPE_II_STMT_LIST (current_class))
7752     java_complete_expand_method (generate_instinit (current_class));
7753
7754   /* Now do the constructors */
7755   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7756     {
7757       int no_body;
7758
7759       if (!DECL_CONSTRUCTOR_P (decl))
7760         continue;
7761
7762       no_body = !DECL_FUNCTION_BODY (decl);
7763       /* Don't generate debug info on line zero when expanding a
7764          generated constructor. */
7765       if (no_body)
7766         restore_line_number_status (1);
7767
7768       java_complete_expand_method (decl);
7769
7770       if (no_body)
7771         restore_line_number_status (0);
7772     }
7773
7774   /* First, do the ordinary methods. */
7775   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7776     {
7777       /* Ctors aren't part of this batch. */
7778       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7779         continue;
7780
7781       /* Skip abstract or native methods -- but do handle native
7782          methods when generating JNI stubs.  */
7783       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7784         {
7785           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7786           continue;
7787         }
7788
7789       if (METHOD_NATIVE (decl))
7790         {
7791           tree body;
7792           current_function_decl = decl;
7793           body = build_jni_stub (decl);
7794           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7795         }
7796
7797       java_complete_expand_method (decl);
7798     }
7799
7800   /* If there is indeed a <clinit>, fully expand it now */
7801   if (clinit)
7802     {
7803       /* Prevent the use of `this' inside <clinit> */
7804       ctxp->explicit_constructor_p = 1;
7805       java_complete_expand_method (clinit);
7806       ctxp->explicit_constructor_p = 0;
7807     }
7808
7809   /* We might have generated a class$ that we now want to expand */
7810   if (TYPE_DOT_CLASS (current_class))
7811     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7812
7813   /* Now verify constructor circularity (stop after the first one we
7814      prove wrong.) */
7815   if (!CLASS_INTERFACE (class_decl))
7816     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7817       if (DECL_CONSTRUCTOR_P (decl)
7818           && verify_constructor_circularity (decl, decl))
7819         break;
7820 }
7821
7822 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7823    safely used in some other methods/constructors.  */
7824
7825 static tree
7826 maybe_generate_pre_expand_clinit (tree class_type)
7827 {
7828   tree current, mdecl;
7829
7830   if (!TYPE_CLINIT_STMT_LIST (class_type))
7831     return NULL_TREE;
7832
7833   /* Go through all static fields and pre expand them */
7834   for (current = TYPE_FIELDS (class_type); current;
7835        current = TREE_CHAIN (current))
7836     if (FIELD_STATIC (current))
7837       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7838
7839   /* Then build the <clinit> method */
7840   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7841                                     clinit_identifier_node, end_params_node);
7842   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7843                        mdecl, NULL_TREE);
7844   start_artificial_method_body (mdecl);
7845
7846   /* We process the list of assignment we produced as the result of
7847      the declaration of initialized static field and add them as
7848      statement to the <clinit> method. */
7849   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7850        current = TREE_CHAIN (current))
7851     {
7852       tree stmt = current;
7853       /* We build the assignment expression that will initialize the
7854          field to its value. There are strict rules on static
7855          initializers (8.5). FIXME */
7856       if (TREE_CODE (stmt) != BLOCK && stmt != empty_stmt_node)
7857         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7858       java_method_add_stmt (mdecl, stmt);
7859     }
7860
7861   end_artificial_method_body (mdecl);
7862
7863   /* Now we want to place <clinit> as the last method (because we need
7864      it at least for interface so that it doesn't interfere with the
7865      dispatch table based lookup. */
7866   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7867     {
7868       current = TREE_CHAIN (TYPE_METHODS (class_type));
7869       TYPE_METHODS (class_type) = current;
7870
7871       while (TREE_CHAIN (current))
7872         current = TREE_CHAIN (current);
7873
7874       TREE_CHAIN (current) = mdecl;
7875       TREE_CHAIN (mdecl) = NULL_TREE;
7876     }
7877
7878   return mdecl;
7879 }
7880
7881 /* Analyzes a method body and look for something that isn't a
7882    MODIFY_EXPR with a constant value.  */
7883
7884 static int
7885 analyze_clinit_body (tree this_class, tree bbody)
7886 {
7887   while (bbody)
7888     switch (TREE_CODE (bbody))
7889       {
7890       case BLOCK:
7891         bbody = BLOCK_EXPR_BODY (bbody);
7892         break;
7893
7894       case EXPR_WITH_FILE_LOCATION:
7895         bbody = EXPR_WFL_NODE (bbody);
7896         break;
7897
7898       case COMPOUND_EXPR:
7899         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
7900           return 1;
7901         bbody = TREE_OPERAND (bbody, 1);
7902         break;
7903
7904       case MODIFY_EXPR:
7905         /* If we're generating to class file and we're dealing with an
7906            array initialization, we return 1 to keep <clinit> */
7907         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
7908             && flag_emit_class_files)
7909           return 1;
7910
7911         /* There are a few cases where we're required to keep
7912            <clinit>:
7913            - If this is an assignment whose operand is not constant,
7914            - If this is an assignment to a non-initialized field,
7915            - If this field is not a member of the current class.
7916         */
7917         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
7918                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
7919                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
7920
7921       default:
7922         return 1;
7923       }
7924   return 0;
7925 }
7926
7927
7928 /* See whether we could get rid of <clinit>. Criteria are: all static
7929    final fields have constant initial values and the body of <clinit>
7930    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7931
7932 static int
7933 maybe_yank_clinit (tree mdecl)
7934 {
7935   tree type, current;
7936   tree fbody, bbody;
7937
7938   if (!DECL_CLINIT_P (mdecl))
7939     return 0;
7940
7941   /* If the body isn't empty, then we keep <clinit>. Note that if
7942      we're emitting classfiles, this isn't enough not to rule it
7943      out. */
7944   fbody = DECL_FUNCTION_BODY (mdecl);
7945   bbody = BLOCK_EXPR_BODY (fbody);
7946   if (bbody && bbody != error_mark_node)
7947     bbody = BLOCK_EXPR_BODY (bbody);
7948   else
7949     return 0;
7950   if (bbody && ! flag_emit_class_files && bbody != empty_stmt_node)
7951     return 0;
7952
7953   type = DECL_CONTEXT (mdecl);
7954   current = TYPE_FIELDS (type);
7955
7956   for (current = (current ? TREE_CHAIN (current) : current);
7957        current; current = TREE_CHAIN (current))
7958     {
7959       tree f_init;
7960
7961       /* We're not interested in non-static fields.  */
7962       if (!FIELD_STATIC (current))
7963         continue;
7964
7965       /* Nor in fields without initializers. */
7966       f_init = DECL_INITIAL (current);
7967       if (f_init == NULL_TREE)
7968         continue;
7969
7970       /* Anything that isn't String or a basic type is ruled out -- or
7971          if we know how to deal with it (when doing things natively) we
7972          should generated an empty <clinit> so that SUID are computed
7973          correctly. */
7974       if (! JSTRING_TYPE_P (TREE_TYPE (current))
7975           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
7976         return 0;
7977
7978       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
7979         return 0;
7980     }
7981
7982   /* Now we analyze the method body and look for something that
7983      isn't a MODIFY_EXPR */
7984   if (bbody != empty_stmt_node && analyze_clinit_body (type, bbody))
7985     return 0;
7986
7987   /* Get rid of <clinit> in the class' list of methods */
7988   if (TYPE_METHODS (type) == mdecl)
7989     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7990   else
7991     for (current = TYPE_METHODS (type); current;
7992          current = TREE_CHAIN (current))
7993       if (TREE_CHAIN (current) == mdecl)
7994         {
7995           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7996           break;
7997         }
7998
7999   return 1;
8000 }
8001
8002 /* Install the argument from MDECL. Suitable to completion and
8003    expansion of mdecl's body.  */
8004
8005 void
8006 start_complete_expand_method (tree mdecl)
8007 {
8008   tree tem;
8009
8010   pushlevel (1);                /* Prepare for a parameter push */
8011   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
8012   DECL_ARGUMENTS (mdecl) = tem;
8013
8014   for (; tem; tem = TREE_CHAIN (tem))
8015     {
8016       /* TREE_CHAIN (tem) will change after pushdecl. */
8017       tree next = TREE_CHAIN (tem);
8018       tree type = TREE_TYPE (tem);
8019       if (targetm.calls.promote_prototypes (type)
8020           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
8021           && INTEGRAL_TYPE_P (type))
8022         type = integer_type_node;
8023       DECL_ARG_TYPE (tem) = type;
8024       layout_decl (tem, 0);
8025       pushdecl (tem);
8026       /* Re-install the next so that the list is kept and the loop
8027          advances. */
8028       TREE_CHAIN (tem) = next;
8029     }
8030   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8031   input_line = DECL_SOURCE_LINE (mdecl);
8032   build_result_decl (mdecl);
8033 }
8034
8035
8036 /* Complete and expand a method.  */
8037
8038 static void
8039 java_complete_expand_method (tree mdecl)
8040 {
8041   tree fbody, block_body, exception_copy;
8042
8043   current_function_decl = mdecl;
8044   /* Fix constructors before expanding them */
8045   if (DECL_CONSTRUCTOR_P (mdecl))
8046     fix_constructors (mdecl);
8047
8048   /* Expand functions that have a body */
8049   if (!DECL_FUNCTION_BODY (mdecl))
8050     return;
8051
8052   fbody = DECL_FUNCTION_BODY (mdecl);
8053   block_body = BLOCK_EXPR_BODY (fbody);
8054   exception_copy = NULL_TREE;
8055
8056   current_function_decl = mdecl;
8057
8058   if (! quiet_flag)
8059     fprintf (stderr, " [%s.",
8060              lang_printable_name (DECL_CONTEXT (mdecl), 0));
8061   announce_function (mdecl);
8062   if (! quiet_flag)
8063     fprintf (stderr, "]");
8064
8065   /* Prepare the function for tree completion */
8066   start_complete_expand_method (mdecl);
8067
8068   /* Install the current this */
8069   current_this = (!METHOD_STATIC (mdecl) ?
8070                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8071
8072   /* Purge the `throws' list of unchecked exceptions (we save a copy
8073      of the list and re-install it later.) */
8074   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8075   purge_unchecked_exceptions (mdecl);
8076
8077   /* Install exceptions thrown with `throws' */
8078   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8079
8080   if (block_body != NULL_TREE)
8081     {
8082       block_body = java_complete_tree (block_body);
8083
8084       /* Before we check initialization, attached all class initialization
8085          variable to the block_body */
8086       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8087                      attach_init_test_initialization_flags, block_body);
8088
8089       if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
8090         {
8091           check_for_initialization (block_body, mdecl);
8092
8093           /* Go through all the flags marking the initialization of
8094              static variables and see whether they're definitively
8095              assigned, in which case the type is remembered as
8096              definitively initialized in MDECL. */
8097           if (STATIC_CLASS_INIT_OPT_P ())
8098             {
8099               /* Always register the context as properly initialized in
8100                  MDECL. This used with caution helps removing extra
8101                  initialization of self. */
8102               if (METHOD_STATIC (mdecl))
8103                 {
8104                   *(htab_find_slot
8105                     (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8106                      DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8107                 }
8108             }
8109         }
8110       ctxp->explicit_constructor_p = 0;
8111     }
8112
8113   BLOCK_EXPR_BODY (fbody) = block_body;
8114
8115   /* If we saw a return but couldn't evaluate it properly, we'll have
8116      an error_mark_node here. */
8117   if (block_body != error_mark_node
8118       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8119       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
8120       && !flag_emit_xref)
8121     missing_return_error (current_function_decl);
8122
8123   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8124   maybe_yank_clinit (mdecl);
8125
8126   /* Pop the current level, with special measures if we found errors. */
8127   if (java_error_count)
8128     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8129   poplevel (1, 0, 1);
8130
8131   /* Pop the exceptions and sanity check */
8132   POP_EXCEPTIONS();
8133   if (currently_caught_type_list)
8134     abort ();
8135
8136   /* Restore the copy of the list of exceptions if emitting xrefs. */
8137   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8138 }
8139
8140 /* For with each class for which there's code to generate. */
8141
8142 static void
8143 java_expand_method_bodies (tree class)
8144 {
8145   tree decl;
8146   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8147     {
8148       tree block;
8149       tree body;
8150
8151       if (! DECL_FUNCTION_BODY (decl))
8152         continue;
8153
8154       current_function_decl = decl;
8155
8156       block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8157
8158       if (TREE_CODE (block) != BLOCK)
8159         abort ();
8160
8161       /* Save the function body for inlining.  */
8162       DECL_SAVED_TREE (decl) = block;
8163
8164       body = BLOCK_EXPR_BODY (block);
8165
8166       if (TREE_TYPE (body) == NULL_TREE)
8167         abort ();
8168
8169       /* It's time to assign the variable flagging static class
8170          initialization based on which classes invoked static methods
8171          are definitely initializing. This should be flagged. */
8172       if (STATIC_CLASS_INIT_OPT_P ())
8173         {
8174           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8175           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8176             {
8177               /* Executed for each statement calling a static function.
8178                  LIST is a TREE_LIST whose PURPOSE is the called function
8179                  and VALUE is a compound whose second operand can be patched
8180                  with static class initialization flag assignments.  */
8181
8182               tree called_method = TREE_PURPOSE (list);
8183               tree compound = TREE_VALUE (list);
8184               tree assignment_compound_list
8185                 = build_tree_list (called_method, NULL);
8186
8187               /* For each class definitely initialized in
8188                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8189                  assignment to the class initialization flag. */
8190               htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8191                              emit_test_initialization,
8192                              assignment_compound_list);
8193
8194               if (TREE_VALUE (assignment_compound_list))
8195                 TREE_OPERAND (compound, 1)
8196                   = TREE_VALUE (assignment_compound_list);
8197             }
8198         }
8199
8200       /* Prepend class initialization to static methods.  */
8201       if (METHOD_STATIC (decl) && ! METHOD_PRIVATE (decl)
8202           && ! flag_emit_class_files
8203           && ! DECL_CLINIT_P (decl)
8204           && ! CLASS_INTERFACE (TYPE_NAME (class)))
8205         {
8206           tree init = build (CALL_EXPR, void_type_node,
8207                              build_address_of (soft_initclass_node),
8208                              build_tree_list (NULL_TREE,
8209                                               build_class_ref (class)),
8210                              NULL_TREE);
8211           TREE_SIDE_EFFECTS (init) = 1;
8212           body = build (COMPOUND_EXPR, TREE_TYPE (body), init, body);
8213           BLOCK_EXPR_BODY (block) = body;
8214         }
8215
8216       /* Wrap synchronized method bodies in a monitorenter
8217          plus monitorexit cleanup.  */
8218       if (METHOD_SYNCHRONIZED (decl) && ! flag_emit_class_files)
8219         {
8220           tree enter, exit, lock;
8221           if (METHOD_STATIC (decl))
8222             lock = build_class_ref (class);
8223           else
8224             lock = DECL_ARGUMENTS (decl);
8225           BUILD_MONITOR_ENTER (enter, lock);
8226           BUILD_MONITOR_EXIT (exit, lock);
8227
8228           body = build (COMPOUND_EXPR, void_type_node,
8229                         enter,
8230                         build (TRY_FINALLY_EXPR, void_type_node, body, exit));
8231           BLOCK_EXPR_BODY (block) = body;
8232         }
8233
8234       /* Expand the the function body.  */
8235       source_end_java_method ();
8236     }
8237 }
8238
8239 \f
8240
8241 /* This section of the code deals with accessing enclosing context
8242    fields either directly by using the relevant access to this$<n> or
8243    by invoking an access method crafted for that purpose.  */
8244
8245 /* Build the necessary access from an inner class to an outer
8246    class. This routine could be optimized to cache previous result
8247    (decl, current_class and returned access).  When an access method
8248    needs to be generated, it always takes the form of a read. It might
8249    be later turned into a write by calling outer_field_access_fix.  */
8250
8251 static tree
8252 build_outer_field_access (tree id, tree decl)
8253 {
8254   tree access = NULL_TREE;
8255   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8256   tree decl_ctx = DECL_CONTEXT (decl);
8257
8258   /* If the immediate enclosing context of the current class is the
8259      field decl's class or inherits from it; build the access as
8260      `this$<n>.<field>'. Note that we will break the `private' barrier
8261      if we're not emitting bytecodes. */
8262   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8263       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8264     {
8265       tree thisn = build_current_thisn (current_class);
8266       access = make_qualified_primary (build_wfl_node (thisn),
8267                                        id, EXPR_WFL_LINECOL (id));
8268     }
8269   /* Otherwise, generate access methods to outer this and access the
8270      field (either using an access method or by direct access.) */
8271   else
8272     {
8273       int lc = EXPR_WFL_LINECOL (id);
8274
8275       /* Now we chain the required number of calls to the access$0 to
8276          get a hold to the enclosing instance we need, and then we
8277          build the field access. */
8278       access = build_access_to_thisn (current_class, decl_ctx, lc);
8279
8280       /* If the field is private and we're generating bytecode, then
8281          we generate an access method */
8282       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8283         {
8284           tree name = build_outer_field_access_methods (decl);
8285           access = build_outer_field_access_expr (lc, decl_ctx,
8286                                                   name, access, NULL_TREE);
8287         }
8288       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8289          Once again we break the `private' access rule from a foreign
8290          class. */
8291       else
8292         access = make_qualified_primary (access, id, lc);
8293     }
8294   return resolve_expression_name (access, NULL);
8295 }
8296
8297 /* Return a nonzero value if NODE describes an outer field inner
8298    access.  */
8299
8300 static int
8301 outer_field_access_p (tree type, tree decl)
8302 {
8303   if (!INNER_CLASS_TYPE_P (type)
8304       || TREE_CODE (decl) != FIELD_DECL
8305       || DECL_CONTEXT (decl) == type)
8306     return 0;
8307
8308   /* If the inner class extends the declaration context of the field
8309      we're trying to access, then this isn't an outer field access */
8310   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8311     return 0;
8312
8313   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8314        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8315     {
8316       if (type == DECL_CONTEXT (decl))
8317         return 1;
8318
8319       if (!DECL_CONTEXT (TYPE_NAME (type)))
8320         {
8321           /* Before we give up, see whether the field is inherited from
8322              the enclosing context we're considering. */
8323           if (inherits_from_p (type, DECL_CONTEXT (decl)))
8324             return 1;
8325           break;
8326         }
8327     }
8328
8329   return 0;
8330 }
8331
8332 /* Return a nonzero value if NODE represents an outer field inner
8333    access that was been already expanded. As a side effect, it returns
8334    the name of the field being accessed and the argument passed to the
8335    access function, suitable for a regeneration of the access method
8336    call if necessary. */
8337
8338 static int
8339 outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8340                                tree *arg)
8341 {
8342   int identified = 0;
8343
8344   if (TREE_CODE (node) != CALL_EXPR)
8345     return 0;
8346
8347   /* Well, gcj generates slightly different tree nodes when compiling
8348      to native or bytecodes. It's the case for function calls. */
8349
8350   if (flag_emit_class_files
8351       && TREE_CODE (node) == CALL_EXPR
8352       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8353     identified = 1;
8354   else if (!flag_emit_class_files)
8355     {
8356       node = TREE_OPERAND (node, 0);
8357
8358       if (node && TREE_OPERAND (node, 0)
8359           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8360         {
8361           node = TREE_OPERAND (node, 0);
8362           if (TREE_OPERAND (node, 0)
8363               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8364               && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8365                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8366             identified = 1;
8367         }
8368     }
8369
8370   if (identified && name && arg_type && arg)
8371     {
8372       tree argument = TREE_OPERAND (node, 1);
8373       *name = DECL_NAME (TREE_OPERAND (node, 0));
8374       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8375       *arg = TREE_VALUE (argument);
8376     }
8377   return identified;
8378 }
8379
8380 /* Detect in NODE an outer field read access from an inner class and
8381    transform it into a write with RHS as an argument. This function is
8382    called from the java_complete_lhs when an assignment to a LHS can
8383    be identified. */
8384
8385 static tree
8386 outer_field_access_fix (tree wfl, tree node, tree rhs)
8387 {
8388   tree name, arg_type, arg;
8389
8390   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8391     {
8392       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8393                                             arg_type, name, arg, rhs);
8394       return java_complete_tree (node);
8395     }
8396   return NULL_TREE;
8397 }
8398
8399 /* Construct the expression that calls an access method:
8400      <type>.access$<n>(<arg1> [, <arg2>]);
8401
8402    ARG2 can be NULL and will be omitted in that case. It will denote a
8403    read access.  */
8404
8405 static tree
8406 build_outer_field_access_expr (int lc, tree type, tree access_method_name,
8407                                tree arg1, tree arg2)
8408 {
8409   tree args, cn, access;
8410
8411   args = arg1 ? arg1 :
8412     build_wfl_node (build_current_thisn (current_class));
8413   args = build_tree_list (NULL_TREE, args);
8414
8415   if (arg2)
8416     args = tree_cons (NULL_TREE, arg2, args);
8417
8418   access = build_method_invocation (build_wfl_node (access_method_name), args);
8419   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8420   return make_qualified_primary (cn, access, lc);
8421 }
8422
8423 static tree
8424 build_new_access_id (void)
8425 {
8426   static int access_n_counter = 1;
8427   char buffer [128];
8428
8429   sprintf (buffer, "access$%d", access_n_counter++);
8430   return get_identifier (buffer);
8431 }
8432
8433 /* Create the static access functions for the outer field DECL. We define a
8434    read:
8435      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8436        return inst$.field;
8437      }
8438    and a write access:
8439      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8440                                      TREE_TYPE (<field>) value$) {
8441        return inst$.field = value$;
8442      }
8443    We should have a usage flags on the DECL so we can lazily turn the ones
8444    we're using for code generation. FIXME.
8445 */
8446
8447 static tree
8448 build_outer_field_access_methods (tree decl)
8449 {
8450   tree id, args, stmt, mdecl;
8451
8452   if (FIELD_INNER_ACCESS_P (decl))
8453     return FIELD_INNER_ACCESS (decl);
8454
8455   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8456
8457   /* Create the identifier and a function named after it. */
8458   id = build_new_access_id ();
8459
8460   /* The identifier is marked as bearing the name of a generated write
8461      access function for outer field accessed from inner classes. */
8462   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8463
8464   /* Create the read access */
8465   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8466   TREE_CHAIN (args) = end_params_node;
8467   stmt = make_qualified_primary (build_wfl_node (inst_id),
8468                                  build_wfl_node (DECL_NAME (decl)), 0);
8469   stmt = build_return (0, stmt);
8470   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8471                                            TREE_TYPE (decl), id, args, stmt);
8472   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8473
8474   /* Create the write access method. No write access for final variable */
8475   if (!FIELD_FINAL (decl))
8476     {
8477       args = build_tree_list (inst_id,
8478                               build_pointer_type (DECL_CONTEXT (decl)));
8479       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8480       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8481       stmt = make_qualified_primary (build_wfl_node (inst_id),
8482                                      build_wfl_node (DECL_NAME (decl)), 0);
8483       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8484                                                 build_wfl_node (wpv_id)));
8485       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8486                                                TREE_TYPE (decl), id,
8487                                                args, stmt);
8488     }
8489   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8490
8491   /* Return the access name */
8492   return FIELD_INNER_ACCESS (decl) = id;
8493 }
8494
8495 /* Build an field access method NAME.  */
8496
8497 static tree
8498 build_outer_field_access_method (tree class, tree type, tree name,
8499                                  tree args, tree body)
8500 {
8501   tree saved_current_function_decl, mdecl;
8502
8503   /* Create the method */
8504   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8505   fix_method_argument_names (args, mdecl);
8506   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8507
8508   /* Attach the method body. */
8509   saved_current_function_decl = current_function_decl;
8510   start_artificial_method_body (mdecl);
8511   java_method_add_stmt (mdecl, body);
8512   end_artificial_method_body (mdecl);
8513   current_function_decl = saved_current_function_decl;
8514
8515   return mdecl;
8516 }
8517
8518 \f
8519 /* This section deals with building access function necessary for
8520    certain kinds of method invocation from inner classes.  */
8521
8522 static tree
8523 build_outer_method_access_method (tree decl)
8524 {
8525   tree saved_current_function_decl, mdecl;
8526   tree args = NULL_TREE, call_args = NULL_TREE;
8527   tree carg, id, body, class;
8528   char buffer [80];
8529   int parm_id_count = 0;
8530
8531   /* Test this abort with an access to a private field */
8532   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8533     abort ();
8534
8535   /* Check the cache first */
8536   if (DECL_FUNCTION_INNER_ACCESS (decl))
8537     return DECL_FUNCTION_INNER_ACCESS (decl);
8538
8539   class = DECL_CONTEXT (decl);
8540
8541   /* Obtain an access identifier and mark it */
8542   id = build_new_access_id ();
8543   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8544
8545   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8546   /* Create the arguments, as much as the original */
8547   for (; carg && carg != end_params_node;
8548        carg = TREE_CHAIN (carg))
8549     {
8550       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8551       args = chainon (args, build_tree_list (get_identifier (buffer),
8552                                              TREE_VALUE (carg)));
8553     }
8554   args = chainon (args, end_params_node);
8555
8556   /* Create the method */
8557   mdecl = create_artificial_method (class, ACC_STATIC,
8558                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8559   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8560   /* There is a potential bug here. We should be able to use
8561      fix_method_argument_names, but then arg names get mixed up and
8562      eventually a constructor will have its this$0 altered and the
8563      outer context won't be assignment properly. The testcase is
8564      stub.java FIXME */
8565   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8566
8567   /* Attach the method body. */
8568   saved_current_function_decl = current_function_decl;
8569   start_artificial_method_body (mdecl);
8570
8571   /* The actual method invocation uses the same args. When invoking a
8572      static methods that way, we don't want to skip the first
8573      argument. */
8574   carg = args;
8575   if (!METHOD_STATIC (decl))
8576     carg = TREE_CHAIN (carg);
8577   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8578     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8579                            call_args);
8580
8581   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8582                                   call_args);
8583   if (!METHOD_STATIC (decl))
8584     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8585                                    body, 0);
8586   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8587     body = build_return (0, body);
8588   java_method_add_stmt (mdecl,body);
8589   end_artificial_method_body (mdecl);
8590   current_function_decl = saved_current_function_decl;
8591
8592   /* Back tag the access function so it know what it accesses */
8593   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8594
8595   /* Tag the current method so it knows it has an access generated */
8596   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8597 }
8598
8599 \f
8600 /* This section of the code deals with building expressions to access
8601    the enclosing instance of an inner class. The enclosing instance is
8602    kept in a generated field called this$<n>, with <n> being the
8603    inner class nesting level (starting from 0.)  */
8604
8605 /* Build an access to a given this$<n>, always chaining access call to
8606    others. Access methods to this$<n> are build on the fly if
8607    necessary. This CAN'T be used to solely access this$<n-1> from
8608    this$<n> (which alway yield to special cases and optimization, see
8609    for example build_outer_field_access).  */
8610
8611 static tree
8612 build_access_to_thisn (tree from, tree to, int lc)
8613 {
8614   tree access = NULL_TREE;
8615
8616   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8617     {
8618       if (!access)
8619         {
8620           access = build_current_thisn (from);
8621           access = build_wfl_node (access);
8622         }
8623       else
8624         {
8625           tree access0_wfl, cn;
8626
8627           maybe_build_thisn_access_method (from);
8628           access0_wfl = build_wfl_node (access0_identifier_node);
8629           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8630           EXPR_WFL_LINECOL (access0_wfl) = lc;
8631           access = build_tree_list (NULL_TREE, access);
8632           access = build_method_invocation (access0_wfl, access);
8633           access = make_qualified_primary (cn, access, lc);
8634         }
8635
8636       /* If FROM isn't an inner class, that's fine, we've done enough.
8637          What we're looking for can be accessed from there.  */
8638       from = DECL_CONTEXT (TYPE_NAME (from));
8639       if (!from)
8640         break;
8641       from = TREE_TYPE (from);
8642     }
8643   return access;
8644 }
8645
8646 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8647    is returned if nothing needs to be generated. Otherwise, the method
8648    generated and a method decl is returned.
8649
8650    NOTE: These generated methods should be declared in a class file
8651    attribute so that they can't be referred to directly.  */
8652
8653 static tree
8654 maybe_build_thisn_access_method (tree type)
8655 {
8656   tree mdecl, args, stmt, rtype;
8657   tree saved_current_function_decl;
8658
8659   /* If TYPE is a top-level class, no access method is required.
8660      If there already is such an access method, bail out. */
8661   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8662     return NULL_TREE;
8663
8664   /* We generate the method. The method looks like:
8665      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8666   */
8667   args = build_tree_list (inst_id, build_pointer_type (type));
8668   TREE_CHAIN (args) = end_params_node;
8669   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8670   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8671                                     access0_identifier_node, args);
8672   fix_method_argument_names (args, mdecl);
8673   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8674   stmt = build_current_thisn (type);
8675   stmt = make_qualified_primary (build_wfl_node (inst_id),
8676                                  build_wfl_node (stmt), 0);
8677   stmt = build_return (0, stmt);
8678
8679   saved_current_function_decl = current_function_decl;
8680   start_artificial_method_body (mdecl);
8681   java_method_add_stmt (mdecl, stmt);
8682   end_artificial_method_body (mdecl);
8683   current_function_decl = saved_current_function_decl;
8684
8685   CLASS_ACCESS0_GENERATED_P (type) = 1;
8686
8687   return mdecl;
8688 }
8689
8690 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8691    the first level of innerclassing. this$1 for the next one, etc...
8692    This function can be invoked with TYPE to NULL, available and then
8693    has to count the parser context.  */
8694
8695 static GTY(()) tree saved_thisn;
8696 static GTY(()) tree saved_type;
8697
8698 static tree
8699 build_current_thisn (tree type)
8700 {
8701   static int saved_i = -1;
8702   static int saved_type_i = 0;
8703   tree decl;
8704   char buffer [24];
8705   int i = 0;
8706
8707   if (type)
8708     {
8709       if (type == saved_type)
8710         i = saved_type_i;
8711       else
8712         {
8713           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8714                decl; decl = DECL_CONTEXT (decl), i++)
8715             ;
8716
8717           saved_type = type;
8718           saved_type_i = i;
8719         }
8720     }
8721   else
8722     i = list_length (GET_CPC_LIST ())-2;
8723
8724   if (i == saved_i)
8725     return saved_thisn;
8726
8727   sprintf (buffer, "this$%d", i);
8728   saved_i = i;
8729   saved_thisn = get_identifier (buffer);
8730   return saved_thisn;
8731 }
8732
8733 /* Return the assignment to the hidden enclosing context `this$<n>'
8734    by the second incoming parameter to the innerclass constructor. The
8735    form used is `this.this$<n> = this$<n>;'.  */
8736
8737 static tree
8738 build_thisn_assign (void)
8739 {
8740   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8741     {
8742       tree thisn = build_current_thisn (current_class);
8743       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8744                                          build_wfl_node (thisn), 0);
8745       tree rhs = build_wfl_node (thisn);
8746       EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8747       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8748     }
8749   return NULL_TREE;
8750 }
8751
8752 \f
8753 /* Building the synthetic `class$' used to implement the `.class' 1.1
8754    extension for non primitive types. This method looks like:
8755
8756     static Class class$(String type) throws NoClassDefFoundError
8757     {
8758       try {return (java.lang.Class.forName (String));}
8759       catch (ClassNotFoundException e) {
8760         throw new NoClassDefFoundError(e.getMessage());}
8761     } */
8762
8763 static GTY(()) tree get_message_wfl;
8764 static GTY(()) tree type_parm_wfl;
8765
8766 static tree
8767 build_dot_class_method (tree class)
8768 {
8769 #define BWF(S) build_wfl_node (get_identifier ((S)))
8770 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8771   tree args, tmp, saved_current_function_decl, mdecl, qual_name;
8772   tree stmt, throw_stmt;
8773
8774   if (!get_message_wfl)
8775     {
8776       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8777       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8778     }
8779
8780   /* Build the arguments */
8781   args = build_tree_list (get_identifier ("type$"),
8782                           build_pointer_type (string_type_node));
8783   TREE_CHAIN (args) = end_params_node;
8784
8785   /* Build the qualified name java.lang.Class.forName */
8786   tmp = MQN (MQN (MQN (BWF ("java"),
8787                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8788
8789   /* Create the "class$" function */
8790   mdecl = create_artificial_method (class, ACC_STATIC,
8791                                     build_pointer_type (class_type_node),
8792                                     classdollar_identifier_node, args);
8793   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8794                    BWF ("NoClassDefFoundError"));
8795   DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE, qual_name);
8796   register_incomplete_type (JDEP_EXCEPTION, qual_name, NULL_TREE, NULL_TREE);
8797   JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
8798     &TREE_VALUE (DECL_FUNCTION_THROWS (mdecl));
8799
8800   /* We start by building the try block. We need to build:
8801        return (java.lang.Class.forName (type)); */
8802   stmt = build_method_invocation (tmp,
8803                                   build_tree_list (NULL_TREE, type_parm_wfl));
8804   stmt = build_return (0, stmt);
8805
8806   /* Now onto the catch block. We start by building the expression
8807      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8808   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8809                                     get_message_wfl, 0);
8810   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8811
8812   /* Build new NoClassDefFoundError (_.getMessage) */
8813   throw_stmt = build_new_invocation
8814     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8815      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8816
8817   /* Build the throw, (it's too early to use BUILD_THROW) */
8818   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8819
8820   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8821   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8822                    BWF ("ClassNotFoundException"));
8823   stmt = encapsulate_with_try_catch (0, qual_name, stmt, throw_stmt);
8824
8825   fix_method_argument_names (args, mdecl);
8826   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8827   saved_current_function_decl = current_function_decl;
8828   start_artificial_method_body (mdecl);
8829   java_method_add_stmt (mdecl, stmt);
8830   end_artificial_method_body (mdecl);
8831   current_function_decl = saved_current_function_decl;
8832   TYPE_DOT_CLASS (class) = mdecl;
8833
8834   return mdecl;
8835 }
8836
8837 static tree
8838 build_dot_class_method_invocation (tree this_class, tree type)
8839 {
8840   tree dot_class_method = TYPE_DOT_CLASS (this_class);
8841   tree sig_id, s, t;
8842
8843   if (TYPE_ARRAY_P (type))
8844     sig_id = build_java_signature (type);
8845   else
8846     sig_id = DECL_NAME (TYPE_NAME (type));
8847
8848   /* Ensure that the proper name separator is used */
8849   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8850                                IDENTIFIER_LENGTH (sig_id));
8851
8852   s = build_string (IDENTIFIER_LENGTH (sig_id),
8853                     IDENTIFIER_POINTER (sig_id));
8854   t = build_method_invocation (build_wfl_node (DECL_NAME (dot_class_method)),
8855                                build_tree_list (NULL_TREE, s));
8856   if (DECL_CONTEXT (dot_class_method) != this_class)
8857     {
8858       tree class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (dot_class_method)));
8859       t = make_qualified_primary (build_wfl_node (class_name), t, 0);
8860     }
8861   return t;
8862 }
8863
8864 /* This section of the code deals with constructor.  */
8865
8866 /* Craft a body for default constructor. Patch existing constructor
8867    bodies with call to super() and field initialization statements if
8868    necessary.  */
8869
8870 static void
8871 fix_constructors (tree mdecl)
8872 {
8873   tree iii;                     /* Instance Initializer Invocation */
8874   tree body = DECL_FUNCTION_BODY (mdecl);
8875   tree thisn_assign, compound = NULL_TREE;
8876   tree class_type = DECL_CONTEXT (mdecl);
8877
8878   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8879     return;
8880   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8881
8882   if (!body)
8883     {
8884       /* It is an error for the compiler to generate a default
8885          constructor if the superclass doesn't have a constructor that
8886          takes no argument, or the same args for an anonymous class */
8887       if (verify_constructor_super (mdecl))
8888         {
8889           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8890           tree save = DECL_NAME (mdecl);
8891           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8892           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8893           parse_error_context
8894             (lookup_cl (TYPE_NAME (class_type)),
8895              "No constructor matching `%s' found in class `%s'",
8896              lang_printable_name (mdecl, 0), n);
8897           DECL_NAME (mdecl) = save;
8898         }
8899
8900       /* The constructor body must be crafted by hand. It's the
8901          constructor we defined when we realize we didn't have the
8902          CLASSNAME() constructor */
8903       start_artificial_method_body (mdecl);
8904
8905       /* Insert an assignment to the this$<n> hidden field, if
8906          necessary */
8907       if ((thisn_assign = build_thisn_assign ()))
8908         java_method_add_stmt (mdecl, thisn_assign);
8909
8910       /* We don't generate a super constructor invocation if we're
8911          compiling java.lang.Object. build_super_invocation takes care
8912          of that. */
8913       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8914
8915       /* FIXME */
8916       if ((iii = build_instinit_invocation (class_type)))
8917         java_method_add_stmt (mdecl, iii);
8918
8919       end_artificial_method_body (mdecl);
8920     }
8921   /* Search for an explicit constructor invocation */
8922   else
8923     {
8924       int found = 0;
8925       int invokes_this = 0;
8926       tree found_call = NULL_TREE;
8927       tree main_block = BLOCK_EXPR_BODY (body);
8928
8929       while (body)
8930         switch (TREE_CODE (body))
8931           {
8932           case CALL_EXPR:
8933             found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8934             if (CALL_THIS_CONSTRUCTOR_P (body))
8935               invokes_this = 1;
8936             body = NULL_TREE;
8937             break;
8938           case COMPOUND_EXPR:
8939           case EXPR_WITH_FILE_LOCATION:
8940             found_call = body;
8941             body = TREE_OPERAND (body, 0);
8942             break;
8943           case BLOCK:
8944             found_call = body;
8945             body = BLOCK_EXPR_BODY (body);
8946             break;
8947           default:
8948             found = 0;
8949             body = NULL_TREE;
8950           }
8951
8952       /* Generate the assignment to this$<n>, if necessary */
8953       if ((thisn_assign = build_thisn_assign ()))
8954         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8955
8956       /* The constructor is missing an invocation of super() */
8957       if (!found)
8958         compound = add_stmt_to_compound (compound, NULL_TREE,
8959                                          build_super_invocation (mdecl));
8960       /* Explicit super() invocation should take place before the
8961          instance initializer blocks. */
8962       else
8963         {
8964           compound = add_stmt_to_compound (compound, NULL_TREE,
8965                                            TREE_OPERAND (found_call, 0));
8966           TREE_OPERAND (found_call, 0) = empty_stmt_node;
8967         }
8968
8969       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
8970
8971       /* Insert the instance initializer block right after. */
8972       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
8973         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
8974
8975       /* Fix the constructor main block if we're adding extra stmts */
8976       if (compound)
8977         {
8978           compound = add_stmt_to_compound (compound, NULL_TREE,
8979                                            BLOCK_EXPR_BODY (main_block));
8980           BLOCK_EXPR_BODY (main_block) = compound;
8981         }
8982     }
8983 }
8984
8985 /* Browse constructors in the super class, searching for a constructor
8986    that doesn't take any argument. Return 0 if one is found, 1
8987    otherwise.  If the current class is an anonymous inner class, look
8988    for something that has the same signature. */
8989
8990 static int
8991 verify_constructor_super (tree mdecl)
8992 {
8993   tree class = CLASSTYPE_SUPER (current_class);
8994   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8995   tree sdecl;
8996
8997   if (!class)
8998     return 0;
8999
9000   if (ANONYMOUS_CLASS_P (current_class))
9001     {
9002       tree mdecl_arg_type;
9003       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
9004       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
9005         if (DECL_CONSTRUCTOR_P (sdecl))
9006           {
9007             tree m_arg_type;
9008             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
9009             if (super_inner)
9010               arg_type = TREE_CHAIN (arg_type);
9011             for (m_arg_type = mdecl_arg_type;
9012                  (arg_type != end_params_node
9013                   && m_arg_type != end_params_node);
9014                  arg_type = TREE_CHAIN (arg_type),
9015                    m_arg_type = TREE_CHAIN (m_arg_type))
9016               if (!valid_method_invocation_conversion_p
9017                      (TREE_VALUE (arg_type),
9018                       TREE_VALUE (m_arg_type)))
9019                 break;
9020
9021             if (arg_type == end_params_node && m_arg_type == end_params_node)
9022               return 0;
9023           }
9024     }
9025   else
9026     {
9027       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
9028         {
9029           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
9030           if (super_inner)
9031             arg = TREE_CHAIN (arg);
9032           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
9033             return 0;
9034         }
9035     }
9036   return 1;
9037 }
9038
9039 /* Generate code for all context remembered for code generation.  */
9040
9041 static GTY(()) tree reversed_class_list;
9042 void
9043 java_expand_classes (void)
9044 {
9045   int save_error_count = 0;
9046   static struct parser_ctxt *cur_ctxp = NULL;
9047
9048   java_parse_abort_on_error ();
9049   if (!(ctxp = ctxp_for_generation))
9050     return;
9051   java_layout_classes ();
9052   java_parse_abort_on_error ();
9053
9054   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9055     {
9056       tree current;
9057       for (current = cur_ctxp->class_list;
9058            current;
9059            current = TREE_CHAIN (current))
9060         gen_indirect_dispatch_tables (TREE_TYPE (current));
9061     }
9062
9063   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9064     {
9065       ctxp = cur_ctxp;
9066       input_filename = ctxp->filename;
9067       lang_init_source (2);            /* Error msgs have method prototypes */
9068       java_complete_expand_classes (); /* Complete and expand classes */
9069       java_parse_abort_on_error ();
9070     }
9071   input_filename = main_input_filename;
9072
9073   /* Find anonymous classes and expand their constructor. This extra pass is
9074      necessary because the constructor itself is only generated when the
9075      method in which it is defined is expanded. */
9076   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9077     {
9078       tree current;
9079       ctxp = cur_ctxp;
9080       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9081         {
9082           output_class = current_class = TREE_TYPE (current);
9083           if (ANONYMOUS_CLASS_P (current_class))
9084             {
9085               tree d;
9086               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9087                 {
9088                   if (DECL_CONSTRUCTOR_P (d))
9089                     {
9090                       restore_line_number_status (1);
9091                       java_complete_expand_method (d);
9092                       restore_line_number_status (0);
9093                       break;    /* There is only one constructor. */
9094                     }
9095                 }
9096             }
9097         }
9098     }
9099
9100   /* Expanding the constructors of anonymous classes generates access
9101      methods.  Scan all the methods looking for null DECL_RESULTs --
9102      this will be the case if a method hasn't been expanded.  */
9103   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9104     {
9105       tree current;
9106       ctxp = cur_ctxp;
9107       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9108         {
9109           tree d;
9110           output_class = current_class = TREE_TYPE (current);
9111           for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9112             {
9113               if (DECL_RESULT (d) == NULL_TREE)
9114                 {
9115                   restore_line_number_status (1);
9116                   java_complete_expand_method (d);
9117                   restore_line_number_status (0);
9118                 }
9119             }
9120         }
9121     }
9122
9123   /* ???  Instead of all this we could iterate around the list of
9124      classes until there were no more un-expanded methods.  It would
9125      take a little longer -- one pass over the whole list of methods
9126      -- but it would be simpler.  Like this:  */
9127 #if 0
9128     {
9129       int something_changed;
9130
9131       do
9132         {
9133           something_changed = 0;
9134           for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9135             {
9136               tree current;
9137               ctxp = cur_ctxp;
9138               for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9139                 {
9140                   tree d;
9141                   output_class = current_class = TREE_TYPE (current);
9142                   for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9143                     {
9144                       if (DECL_RESULT (d) == NULL_TREE)
9145                         {
9146                           something_changed = 1;
9147                           restore_line_number_status (1);
9148                           java_complete_expand_method (d);
9149                           restore_line_number_status (0);
9150                         }
9151                     }
9152                 }
9153             }
9154         }
9155       while (something_changed);
9156     }
9157 #endif
9158
9159   /* If we've found error at that stage, don't try to generate
9160      anything, unless we're emitting xrefs or checking the syntax only
9161      (but not using -fsyntax-only for the purpose of generating
9162      bytecode. */
9163   if (java_error_count && !flag_emit_xref
9164       && (!flag_syntax_only && !flag_emit_class_files))
9165     return;
9166
9167   /* Now things are stable, go for generation of the class data. */
9168
9169   /* We pessimistically marked all methods and fields external until
9170      we knew what set of classes we were planning to compile.  Now mark
9171      those that will be generated locally as not external.  */
9172   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9173     {
9174       tree current;
9175       ctxp = cur_ctxp;
9176       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9177         java_mark_class_local (TREE_TYPE (current));
9178     }
9179
9180   /* Compile the classes.  */
9181   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9182     {
9183       tree current;
9184       reversed_class_list = NULL;
9185
9186       ctxp = cur_ctxp;
9187
9188       /* We write out the classes in reverse order.  This ensures that
9189          inner classes are written before their containing classes,
9190          which is important for parallel builds.  Otherwise, the
9191          class file for the outer class may be found, but the class
9192          file for the inner class may not be present.  In that
9193          situation, the compiler cannot fall back to the original
9194          source, having already read the outer class, so we must
9195          prevent that situation.  */
9196       for (current = ctxp->class_list;
9197            current;
9198            current = TREE_CHAIN (current))
9199         reversed_class_list
9200           = tree_cons (NULL_TREE, current, reversed_class_list);
9201
9202       for (current = reversed_class_list;
9203            current;
9204            current = TREE_CHAIN (current))
9205         {
9206           output_class = current_class = TREE_TYPE (TREE_VALUE (current));
9207           if (flag_emit_class_files)
9208             write_classfile (current_class);
9209           if (flag_emit_xref)
9210             expand_xref (current_class);
9211           else if (! flag_syntax_only)
9212             java_expand_method_bodies (current_class);
9213         }
9214     }
9215 }
9216
9217 void
9218 java_finish_classes (void)
9219 {
9220   static struct parser_ctxt *cur_ctxp = NULL;
9221   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9222     {
9223       tree current;
9224       ctxp = cur_ctxp;
9225       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9226         {
9227           output_class = current_class = TREE_TYPE (current);
9228           finish_class ();
9229         }
9230     }
9231 }
9232
9233 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9234    a tree list node containing RIGHT. Fore coming RIGHTs will be
9235    chained to this hook. LOCATION contains the location of the
9236    separating `.' operator.  */
9237
9238 static tree
9239 make_qualified_primary (tree primary, tree right, int location)
9240 {
9241   tree wfl;
9242
9243   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9244     wfl = build_wfl_wrap (primary, location);
9245   else
9246     {
9247       wfl = primary;
9248       /* If wfl wasn't qualified, we build a first anchor */
9249       if (!EXPR_WFL_QUALIFICATION (wfl))
9250         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9251     }
9252
9253   /* And chain them */
9254   EXPR_WFL_LINECOL (right) = location;
9255   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9256   PRIMARY_P (wfl) =  1;
9257   return wfl;
9258 }
9259
9260 /* Simple merge of two name separated by a `.' */
9261
9262 static tree
9263 merge_qualified_name (tree left, tree right)
9264 {
9265   tree node;
9266   if (!left && !right)
9267     return NULL_TREE;
9268
9269   if (!left)
9270     return right;
9271
9272   if (!right)
9273     return left;
9274
9275   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9276                 IDENTIFIER_LENGTH (left));
9277   obstack_1grow (&temporary_obstack, '.');
9278   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9279                  IDENTIFIER_LENGTH (right));
9280   node =  get_identifier (obstack_base (&temporary_obstack));
9281   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9282   QUALIFIED_P (node) = 1;
9283   return node;
9284 }
9285
9286 /* Merge the two parts of a qualified name into LEFT.  Set the
9287    location information of the resulting node to LOCATION, usually
9288    inherited from the location information of the `.' operator. */
9289
9290 static tree
9291 make_qualified_name (tree left, tree right, int location)
9292 {
9293 #ifdef USE_COMPONENT_REF
9294   tree node = build (COMPONENT_REF, NULL_TREE, left, right);
9295   EXPR_WFL_LINECOL (node) = location;
9296   return node;
9297 #else
9298   tree left_id = EXPR_WFL_NODE (left);
9299   tree right_id = EXPR_WFL_NODE (right);
9300   tree wfl, merge;
9301
9302   merge = merge_qualified_name (left_id, right_id);
9303
9304   /* Left wasn't qualified and is now qualified */
9305   if (!QUALIFIED_P (left_id))
9306     {
9307       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9308       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9309       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9310     }
9311
9312   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9313   EXPR_WFL_LINECOL (wfl) = location;
9314   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9315
9316   EXPR_WFL_NODE (left) = merge;
9317   return left;
9318 #endif
9319 }
9320
9321 /* Extract the last identifier component of the qualified in WFL. The
9322    last identifier is removed from the linked list */
9323
9324 static tree
9325 cut_identifier_in_qualified (tree wfl)
9326 {
9327   tree q;
9328   tree previous = NULL_TREE;
9329   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9330     if (!TREE_CHAIN (q))
9331       {
9332         if (!previous)
9333           /* Operating on a non qualified qualified WFL.  */
9334           abort ();
9335
9336         TREE_CHAIN (previous) = NULL_TREE;
9337         return TREE_PURPOSE (q);
9338       }
9339 }
9340
9341 /* Resolve the expression name NAME. Return its decl.  */
9342
9343 static tree
9344 resolve_expression_name (tree id, tree *orig)
9345 {
9346   tree name = EXPR_WFL_NODE (id);
9347   tree decl;
9348
9349   /* 6.5.5.1: Simple expression names */
9350   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9351     {
9352       /* 15.13.1: NAME can appear within the scope of a local variable
9353          declaration */
9354       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9355         return decl;
9356
9357       /* 15.13.1: NAME can appear within a class declaration */
9358       else
9359         {
9360           decl = lookup_field_wrapper (current_class, name);
9361           if (decl)
9362             {
9363               tree access = NULL_TREE;
9364               int fs = FIELD_STATIC (decl);
9365
9366               /* If we're accessing an outer scope local alias, make
9367                  sure we change the name of the field we're going to
9368                  build access to. */
9369               if (FIELD_LOCAL_ALIAS_USED (decl))
9370                 name = DECL_NAME (decl);
9371
9372               check_deprecation (id, decl);
9373
9374               /* Instance variable (8.3.1.1) can't appear within
9375                  static method, static initializer or initializer for
9376                  a static variable. */
9377               if (!fs && METHOD_STATIC (current_function_decl))
9378                 {
9379                   static_ref_err (id, name, current_class);
9380                   return error_mark_node;
9381                 }
9382               /* Instance variables can't appear as an argument of
9383                  an explicit constructor invocation */
9384               if (!fs && ctxp->explicit_constructor_p
9385                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9386                 {
9387                   parse_error_context
9388                     (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9389                   return error_mark_node;
9390                 }
9391
9392               /* If we're processing an inner class and we're trying
9393                  to access a field belonging to an outer class, build
9394                  the access to the field */
9395               if (!fs && outer_field_access_p (current_class, decl))
9396                 {
9397                   if (CLASS_STATIC (TYPE_NAME (current_class)))
9398                     {
9399                       static_ref_err (id, DECL_NAME (decl), current_class);
9400                       return error_mark_node;
9401                     }
9402                   access = build_outer_field_access (id, decl);
9403                   if (orig)
9404                     *orig = access;
9405                   return access;
9406                 }
9407
9408               /* Otherwise build what it takes to access the field */
9409               access = build_field_ref ((fs ? NULL_TREE : current_this),
9410                                         DECL_CONTEXT (decl), name);
9411               if (fs)
9412                 access = maybe_build_class_init_for_field (decl, access);
9413               /* We may be asked to save the real field access node */
9414               if (orig)
9415                 *orig = access;
9416               /* Last check: can we access the field? */
9417               if (not_accessible_p (current_class, decl, NULL_TREE, 0))
9418                 {
9419                   not_accessible_field_error (id, decl);
9420                   return error_mark_node;
9421                 }
9422               /* And we return what we got */
9423               return access;
9424             }
9425           /* Fall down to error report on undefined variable */
9426         }
9427     }
9428   /* 6.5.5.2 Qualified Expression Names */
9429   else
9430     {
9431       if (orig)
9432         *orig = NULL_TREE;
9433       qualify_ambiguous_name (id);
9434       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9435       /* 15.10.2: Accessing Superclass Members using super */
9436       return resolve_field_access (id, orig, NULL);
9437     }
9438
9439   /* We've got an error here */
9440   if (INNER_CLASS_TYPE_P (current_class))
9441     parse_error_context (id,
9442                          "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9443                          IDENTIFIER_POINTER (name),
9444                          IDENTIFIER_POINTER (DECL_NAME
9445                                              (TYPE_NAME (current_class))));
9446   else
9447     parse_error_context (id, "Undefined variable `%s'",
9448                          IDENTIFIER_POINTER (name));
9449
9450   return error_mark_node;
9451 }
9452
9453 static void
9454 static_ref_err (tree wfl, tree field_id, tree class_type)
9455 {
9456   parse_error_context
9457     (wfl,
9458      "Can't make a static reference to nonstatic variable `%s' in class `%s'",
9459      IDENTIFIER_POINTER (field_id),
9460      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9461 }
9462
9463 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9464    We return something suitable to generate the field access. We also
9465    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9466    recipient's address can be null. */
9467
9468 static tree
9469 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9470 {
9471   int is_static = 0;
9472   tree field_ref;
9473   tree decl, where_found, type_found;
9474
9475   if (resolve_qualified_expression_name (qual_wfl, &decl,
9476                                          &where_found, &type_found))
9477     return error_mark_node;
9478
9479   /* Resolve the LENGTH field of an array here */
9480   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9481       && type_found && TYPE_ARRAY_P (type_found)
9482       && ! flag_emit_class_files && ! flag_emit_xref)
9483     {
9484       tree length = build_java_array_length_access (where_found);
9485       field_ref = length;
9486
9487       /* In case we're dealing with a static array, we need to
9488          initialize its class before the array length can be fetched.
9489          It's also a good time to create a DECL_RTL for the field if
9490          none already exists, otherwise if the field was declared in a
9491          class found in an external file and hasn't been (and won't
9492          be) accessed for its value, none will be created. */
9493       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9494         {
9495           build_static_field_ref (where_found);
9496           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9497         }
9498     }
9499   /* We might have been trying to resolve field.method(). In which
9500      case, the resolution is over and decl is the answer */
9501   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9502     field_ref = decl;
9503   else if (JDECL_P (decl))
9504     {
9505       if (!type_found)
9506         type_found = DECL_CONTEXT (decl);
9507       is_static = FIELD_STATIC (decl);
9508       field_ref = build_field_ref ((is_static && !flag_emit_xref?
9509                                     NULL_TREE : where_found),
9510                                    type_found, DECL_NAME (decl));
9511       if (field_ref == error_mark_node)
9512         return error_mark_node;
9513       if (is_static)
9514         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9515
9516       /* If we're looking at a static field, we may need to generate a
9517          class initialization for it.  This can happen when the access
9518          looks like `field.ref', where `field' is a static field in an
9519          interface we implement.  */
9520       if (!flag_emit_class_files
9521           && !flag_emit_xref
9522           && TREE_CODE (where_found) == VAR_DECL
9523           && FIELD_STATIC (where_found))
9524         {
9525           build_static_field_ref (where_found);
9526           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9527         }
9528     }
9529   else
9530     field_ref = decl;
9531
9532   if (field_decl)
9533     *field_decl = decl;
9534   if (field_type)
9535     *field_type = (QUAL_DECL_TYPE (decl) ?
9536                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9537   return field_ref;
9538 }
9539
9540 /* If NODE is an access to f static field, strip out the class
9541    initialization part and return the field decl, otherwise, return
9542    NODE. */
9543
9544 static tree
9545 strip_out_static_field_access_decl (tree node)
9546 {
9547   if (TREE_CODE (node) == COMPOUND_EXPR)
9548     {
9549       tree op1 = TREE_OPERAND (node, 1);
9550       if (TREE_CODE (op1) == COMPOUND_EXPR)
9551          {
9552            tree call = TREE_OPERAND (op1, 0);
9553            if (TREE_CODE (call) == CALL_EXPR
9554                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9555                && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9556                == soft_initclass_node)
9557              return TREE_OPERAND (op1, 1);
9558          }
9559       else if (JDECL_P (op1))
9560         return op1;
9561     }
9562   return node;
9563 }
9564
9565 /* 6.5.5.2: Qualified Expression Names */
9566
9567 static int
9568 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9569                                    tree *where_found, tree *type_found)
9570 {
9571   int from_type = 0;            /* Field search initiated from a type */
9572   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9573   int previous_call_static = 0;
9574   int is_static;
9575   tree decl = NULL_TREE, type = NULL_TREE, q;
9576   /* For certain for of inner class instantiation */
9577   tree saved_current, saved_this;
9578 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9579   { current_class = saved_current; current_this = saved_this;}
9580
9581   *type_found = *where_found = NULL_TREE;
9582
9583   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9584     {
9585       tree qual_wfl = QUAL_WFL (q);
9586       tree ret_decl;            /* for EH checking */
9587       int location;             /* for EH checking */
9588
9589       /* 15.10.1 Field Access Using a Primary */
9590       switch (TREE_CODE (qual_wfl))
9591         {
9592         case CALL_EXPR:
9593         case NEW_CLASS_EXPR:
9594           /* If the access to the function call is a non static field,
9595              build the code to access it. */
9596           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9597             {
9598               decl = maybe_access_field (decl, *where_found,
9599                                          DECL_CONTEXT (decl));
9600               if (decl == error_mark_node)
9601                 return 1;
9602             }
9603
9604           /* And code for the function call */
9605           if (complete_function_arguments (qual_wfl))
9606             return 1;
9607
9608           /* We might have to setup a new current class and a new this
9609              for the search of an inner class, relative to the type of
9610              a expression resolved as `decl'. The current values are
9611              saved and restored shortly after */
9612           saved_current = current_class;
9613           saved_this = current_this;
9614           if (decl
9615               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9616                   || from_qualified_this))
9617             {
9618               /* If we still have `from_qualified_this', we have the form
9619                  <T>.this.f() and we need to build <T>.this */
9620               if (from_qualified_this)
9621                 {
9622                   decl = build_access_to_thisn (current_class, type, 0);
9623                   decl = java_complete_tree (decl);
9624                   type = TREE_TYPE (TREE_TYPE (decl));
9625                 }
9626               current_class = type;
9627               current_this = decl;
9628               from_qualified_this = 0;
9629             }
9630
9631           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9632             CALL_USING_SUPER (qual_wfl) = 1;
9633           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9634                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9635           *where_found = patch_method_invocation (qual_wfl, decl, type,
9636                                                   from_super,
9637                                                   &is_static, &ret_decl);
9638           from_super = 0;
9639           if (*where_found == error_mark_node)
9640             {
9641               RESTORE_THIS_AND_CURRENT_CLASS;
9642               return 1;
9643             }
9644           *type_found = type = QUAL_DECL_TYPE (*where_found);
9645
9646           *where_found = force_evaluation_order (*where_found);
9647
9648           /* If we're creating an inner class instance, check for that
9649              an enclosing instance is in scope */
9650           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9651               && INNER_ENCLOSING_SCOPE_CHECK (type))
9652             {
9653               parse_error_context
9654                 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
9655                  lang_printable_name (type, 0),
9656                  (!current_this ? "" :
9657                   "; an explicit one must be provided when creating this inner class"));
9658               RESTORE_THIS_AND_CURRENT_CLASS;
9659               return 1;
9660             }
9661
9662           /* In case we had to change then to resolve a inner class
9663              instantiation using a primary qualified by a `new' */
9664           RESTORE_THIS_AND_CURRENT_CLASS;
9665
9666           if (location)
9667             {
9668               tree arguments = NULL_TREE;
9669               if (TREE_CODE (qual_wfl) == CALL_EXPR
9670                   && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9671                 arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9672               check_thrown_exceptions (location, ret_decl, arguments);
9673             }
9674
9675           /* If the previous call was static and this one is too,
9676              build a compound expression to hold the two (because in
9677              that case, previous function calls aren't transported as
9678              forcoming function's argument. */
9679           if (previous_call_static && is_static)
9680             {
9681               decl = build (COMPOUND_EXPR, TREE_TYPE (*where_found),
9682                             decl, *where_found);
9683               TREE_SIDE_EFFECTS (decl) = 1;
9684             }
9685           else
9686             {
9687               previous_call_static = is_static;
9688               decl = *where_found;
9689             }
9690           from_type = 0;
9691           continue;
9692
9693         case NEW_ARRAY_EXPR:
9694         case NEW_ANONYMOUS_ARRAY_EXPR:
9695           *where_found = decl = java_complete_tree (qual_wfl);
9696           if (decl == error_mark_node)
9697             return 1;
9698           *type_found = type = QUAL_DECL_TYPE (decl);
9699           continue;
9700
9701         case CONVERT_EXPR:
9702           *where_found = decl = java_complete_tree (qual_wfl);
9703           if (decl == error_mark_node)
9704             return 1;
9705           *type_found = type = QUAL_DECL_TYPE (decl);
9706           from_cast = 1;
9707           continue;
9708
9709         case CONDITIONAL_EXPR:
9710         case STRING_CST:
9711         case MODIFY_EXPR:
9712           *where_found = decl = java_complete_tree (qual_wfl);
9713           if (decl == error_mark_node)
9714             return 1;
9715           *type_found = type = QUAL_DECL_TYPE (decl);
9716           continue;
9717
9718         case ARRAY_REF:
9719           /* If the access to the function call is a non static field,
9720              build the code to access it. */
9721           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9722             {
9723               decl = maybe_access_field (decl, *where_found, type);
9724               if (decl == error_mark_node)
9725                 return 1;
9726             }
9727           /* And code for the array reference expression */
9728           decl = java_complete_tree (qual_wfl);
9729           if (decl == error_mark_node)
9730             return 1;
9731           type = QUAL_DECL_TYPE (decl);
9732           continue;
9733
9734         case PLUS_EXPR:
9735           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9736             return 1;
9737           if ((type = patch_string (decl)))
9738             decl = type;
9739           *where_found = QUAL_RESOLUTION (q) = decl;
9740           *type_found = type = TREE_TYPE (decl);
9741           break;
9742
9743         case CLASS_LITERAL:
9744           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9745             return 1;
9746           *where_found = QUAL_RESOLUTION (q) = decl;
9747           *type_found = type = TREE_TYPE (decl);
9748           break;
9749
9750         default:
9751           /* Fix for -Wall Just go to the next statement. Don't
9752              continue */
9753           break;
9754         }
9755
9756       /* If we fall here, we weren't processing a (static) function call. */
9757       previous_call_static = 0;
9758
9759       /* It can be the keyword THIS */
9760       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9761           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9762         {
9763           if (!current_this)
9764             {
9765               parse_error_context
9766                 (wfl, "Keyword `this' used outside allowed context");
9767               return 1;
9768             }
9769           if (ctxp->explicit_constructor_p
9770               && type == current_class)
9771             {
9772               parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9773               return 1;
9774             }
9775           /* We have to generate code for intermediate access */
9776           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9777             {
9778               *where_found = decl = current_this;
9779               *type_found = type = QUAL_DECL_TYPE (decl);
9780             }
9781           /* We're trying to access the this from somewhere else. Make sure
9782              it's allowed before doing so. */
9783           else
9784             {
9785               if (!enclosing_context_p (type, current_class))
9786                 {
9787                   char *p  = xstrdup (lang_printable_name (type, 0));
9788                   parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9789                                        p, p,
9790                                        lang_printable_name (current_class, 0));
9791                   free (p);
9792                   return 1;
9793                 }
9794               from_qualified_this = 1;
9795               /* If there's nothing else after that, we need to
9796                  produce something now, otherwise, the section of the
9797                  code that needs to produce <T>.this will generate
9798                  what is necessary. */
9799               if (!TREE_CHAIN (q))
9800                 {
9801                   decl = build_access_to_thisn (current_class, type, 0);
9802                   *where_found = decl = java_complete_tree (decl);
9803                   *type_found = type = TREE_TYPE (decl);
9804                 }
9805             }
9806
9807           from_type = 0;
9808           continue;
9809         }
9810
9811       /* 15.10.2 Accessing Superclass Members using SUPER */
9812       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9813           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9814         {
9815           tree node;
9816           /* Check on the restricted use of SUPER */
9817           if (METHOD_STATIC (current_function_decl)
9818               || current_class == object_type_node)
9819             {
9820               parse_error_context
9821                 (wfl, "Keyword `super' used outside allowed context");
9822               return 1;
9823             }
9824           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9825           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9826                              CLASSTYPE_SUPER (current_class),
9827                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9828           *where_found = decl = java_complete_tree (node);
9829           if (decl == error_mark_node)
9830             return 1;
9831           *type_found = type = QUAL_DECL_TYPE (decl);
9832           from_super = from_type = 1;
9833           continue;
9834         }
9835
9836       /* 15.13.1: Can't search for field name in packages, so we
9837          assume a variable/class name was meant. */
9838       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9839         {
9840           tree name;
9841           if ((decl = resolve_package (wfl, &q, &name)))
9842             {
9843               tree list;
9844               *where_found = decl;
9845
9846               check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
9847
9848               /* We want to be absolutely sure that the class is laid
9849                  out. We're going to search something inside it. */
9850               *type_found = type = TREE_TYPE (decl);
9851               layout_class (type);
9852               from_type = 1;
9853
9854               /* Fix them all the way down, if any are left. */
9855               if (q)
9856                 {
9857                   list = TREE_CHAIN (q);
9858                   while (list)
9859                     {
9860                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9861                       list = TREE_CHAIN (list);
9862                     }
9863                 }
9864             }
9865           else
9866             {
9867               if (from_super || from_cast)
9868                 parse_error_context
9869                   ((from_cast ? qual_wfl : wfl),
9870                    "No variable `%s' defined in class `%s'",
9871                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9872                    lang_printable_name (type, 0));
9873               else
9874                 parse_error_context
9875                   (qual_wfl, "Undefined variable or class name: `%s'",
9876                    IDENTIFIER_POINTER (name));
9877               return 1;
9878             }
9879         }
9880
9881       /* We have a type name. It's been already resolved when the
9882          expression was qualified. */
9883       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9884         {
9885           decl = QUAL_RESOLUTION (q);
9886
9887           /* Sneak preview. If next we see a `new', we're facing a
9888              qualification which resulted in a type being selected
9889              instead of a field.  Report the error.  */
9890           if(TREE_CHAIN (q)
9891              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9892             {
9893               parse_error_context (qual_wfl, "Undefined variable `%s'",
9894                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9895               return 1;
9896             }
9897
9898           check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
9899
9900           check_deprecation (qual_wfl, decl);
9901
9902           type = TREE_TYPE (decl);
9903           from_type = 1;
9904         }
9905       /* We resolve an expression name */
9906       else
9907         {
9908           tree field_decl = NULL_TREE;
9909
9910           /* If there exists an early resolution, use it. That occurs
9911              only once and we know that there are more things to
9912              come. Don't do that when processing something after SUPER
9913              (we need more thing to be put in place below */
9914           if (!from_super && QUAL_RESOLUTION (q))
9915             {
9916               decl = QUAL_RESOLUTION (q);
9917               if (!type)
9918                 {
9919                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9920                     {
9921                       if (current_this)
9922                         *where_found = current_this;
9923                       else
9924                         {
9925                           static_ref_err (qual_wfl, DECL_NAME (decl),
9926                                           current_class);
9927                           return 1;
9928                         }
9929                       if (outer_field_access_p (current_class, decl))
9930                         decl = build_outer_field_access (qual_wfl, decl);
9931                     }
9932                   else
9933                     {
9934                       *where_found = TREE_TYPE (decl);
9935                       if (TREE_CODE (*where_found) == POINTER_TYPE)
9936                         *where_found = TREE_TYPE (*where_found);
9937                     }
9938                 }
9939             }
9940
9941           /* Report and error if we're using a numerical literal as a
9942              qualifier. It can only be an INTEGER_CST. */
9943           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9944             {
9945               parse_error_context
9946                 (wfl, "Can't use type `%s' as a qualifier",
9947                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
9948               return 1;
9949             }
9950
9951           /* We have to search for a field, knowing the type of its
9952              container. The flag FROM_TYPE indicates that we resolved
9953              the last member of the expression as a type name, which
9954              means that for the resolution of this field, we'll look
9955              for other errors than if it was resolved as a member of
9956              an other field. */
9957           else
9958             {
9959               int is_static;
9960               tree field_decl_type; /* For layout */
9961
9962               if (!from_type && !JREFERENCE_TYPE_P (type))
9963                 {
9964                   parse_error_context
9965                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9966                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9967                      lang_printable_name (type, 0),
9968                      IDENTIFIER_POINTER (DECL_NAME (decl)));
9969                   return 1;
9970                 }
9971
9972               field_decl = lookup_field_wrapper (type,
9973                                                  EXPR_WFL_NODE (qual_wfl));
9974
9975               /* Maybe what we're trying to access to is an inner
9976                  class, only if decl is a TYPE_DECL. */
9977               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9978                 {
9979                   tree ptr, inner_decl;
9980
9981                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9982                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9983                   if (inner_decl)
9984                     {
9985                       check_inner_class_access (inner_decl, decl, qual_wfl);
9986                       type = TREE_TYPE (inner_decl);
9987                       decl = inner_decl;
9988                       from_type = 1;
9989                       continue;
9990                     }
9991                 }
9992
9993               if (field_decl == NULL_TREE)
9994                 {
9995                   parse_error_context
9996                     (qual_wfl, "No variable `%s' defined in type `%s'",
9997                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9998                      GET_TYPE_NAME (type));
9999                   return 1;
10000                 }
10001               if (field_decl == error_mark_node)
10002                 return 1;
10003
10004               /* Layout the type of field_decl, since we may need
10005                  it. Don't do primitive types or loaded classes. The
10006                  situation of non primitive arrays may not handled
10007                  properly here. FIXME */
10008               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
10009                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
10010               else
10011                 field_decl_type = TREE_TYPE (field_decl);
10012               if (!JPRIMITIVE_TYPE_P (field_decl_type)
10013                   && !CLASS_LOADED_P (field_decl_type)
10014                   && !TYPE_ARRAY_P (field_decl_type))
10015                 resolve_and_layout (field_decl_type, NULL_TREE);
10016
10017               /* Check on accessibility here */
10018               if (not_accessible_p (current_class, field_decl,
10019                                     DECL_CONTEXT (field_decl), from_super))
10020                 return not_accessible_field_error (qual_wfl,field_decl);
10021               check_deprecation (qual_wfl, field_decl);
10022
10023               /* There are things to check when fields are accessed
10024                  from type. There are no restrictions on a static
10025                  declaration of the field when it is accessed from an
10026                  interface */
10027               is_static = FIELD_STATIC (field_decl);
10028               if (!from_super && from_type
10029                   && !TYPE_INTERFACE_P (type)
10030                   && !is_static
10031                   && (current_function_decl
10032                       && METHOD_STATIC (current_function_decl)))
10033                 {
10034                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
10035                   return 1;
10036                 }
10037               from_cast = from_super = 0;
10038
10039               /* It's an access from a type but it isn't static, we
10040                  make it relative to `this'. */
10041               if (!is_static && from_type)
10042                 decl = current_this;
10043
10044               /* If we need to generate something to get a proper
10045                  handle on what this field is accessed from, do it
10046                  now. */
10047               if (!is_static)
10048                 {
10049                   decl = maybe_access_field (decl, *where_found, *type_found);
10050                   if (decl == error_mark_node)
10051                     return 1;
10052                 }
10053
10054               /* We want to keep the location were found it, and the type
10055                  we found. */
10056               *where_found = decl;
10057               *type_found = type;
10058
10059               /* Generate the correct expression for field access from
10060                  qualified this */
10061               if (from_qualified_this)
10062                 {
10063                   field_decl = build_outer_field_access (qual_wfl, field_decl);
10064                   from_qualified_this = 0;
10065                 }
10066
10067               /* This is the decl found and eventually the next one to
10068                  search from */
10069               decl = field_decl;
10070             }
10071           from_type = 0;
10072           type = QUAL_DECL_TYPE (decl);
10073
10074           /* Sneak preview. If decl is qualified by a `new', report
10075              the error here to be accurate on the peculiar construct */
10076           if (TREE_CHAIN (q)
10077               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10078               && !JREFERENCE_TYPE_P (type))
10079             {
10080               parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
10081                                    lang_printable_name (type, 0));
10082               return 1;
10083             }
10084         }
10085       /* `q' might have changed due to a after package resolution
10086          re-qualification */
10087       if (!q)
10088         break;
10089     }
10090   *found_decl = decl;
10091   return 0;
10092 }
10093
10094 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10095    can't be accessed from REFERENCE (a record type). If MEMBER
10096    features a protected access, we then use WHERE which, if non null,
10097    holds the type of MEMBER's access that is checked against
10098    6.6.2.1. This function should be used when decl is a field or a
10099    method.  */
10100
10101 static int
10102 not_accessible_p (tree reference, tree member, tree where, int from_super)
10103 {
10104   int access_flag = get_access_flags_from_decl (member);
10105
10106   /* Inner classes are processed by check_inner_class_access */
10107   if (INNER_CLASS_TYPE_P (reference))
10108     return 0;
10109
10110   /* Access always granted for members declared public */
10111   if (access_flag & ACC_PUBLIC)
10112     return 0;
10113
10114   /* Check access on protected members */
10115   if (access_flag & ACC_PROTECTED)
10116     {
10117       /* Access granted if it occurs from within the package
10118          containing the class in which the protected member is
10119          declared */
10120       if (class_in_current_package (DECL_CONTEXT (member)))
10121         return 0;
10122
10123       /* If accessed with the form `super.member', then access is granted */
10124       if (from_super)
10125         return 0;
10126
10127       /* If where is active, access was made through a
10128          qualifier. Access is granted if the type of the qualifier is
10129          or is a sublass of the type the access made from (6.6.2.1.)  */
10130       if (where && !inherits_from_p (reference, where))
10131         return 1;
10132
10133       /* Otherwise, access is granted if occurring from the class where
10134          member is declared or a subclass of it. Find the right
10135          context to perform the check */
10136       if (PURE_INNER_CLASS_TYPE_P (reference))
10137         {
10138           while (INNER_CLASS_TYPE_P (reference))
10139             {
10140               if (inherits_from_p (reference, DECL_CONTEXT (member)))
10141                 return 0;
10142               reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10143             }
10144         }
10145       if (inherits_from_p (reference, DECL_CONTEXT (member)))
10146         return 0;
10147       return 1;
10148     }
10149
10150   /* Check access on private members. Access is granted only if it
10151      occurs from within the class in which it is declared -- that does
10152      it for innerclasses too. */
10153   if (access_flag & ACC_PRIVATE)
10154     {
10155       if (reference == DECL_CONTEXT (member))
10156         return 0;
10157       if (enclosing_context_p (reference, DECL_CONTEXT (member)))
10158         return 0;
10159       return 1;
10160     }
10161
10162   /* Default access is permitted only when occurring from within the
10163      package in which the context (MEMBER) is declared.  */
10164   return !class_in_current_package (DECL_CONTEXT (member));
10165 }
10166
10167 /* Test deprecated decl access.  */
10168 static void
10169 check_deprecation (tree wfl, tree decl)
10170 {
10171   const char *file;
10172   tree elt;
10173
10174   if (! flag_deprecated)
10175     return;
10176
10177   /* We want to look at the element type of arrays here, so we strip
10178      all surrounding array types.  */
10179   if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10180     {
10181       elt = TREE_TYPE (decl);
10182       while (TYPE_ARRAY_P (elt))
10183         elt = TYPE_ARRAY_ELEMENT (elt);
10184       /* We'll end up with a pointer type, so we use TREE_TYPE to go
10185          to the record.  */
10186       decl = TYPE_NAME (TREE_TYPE (elt));
10187     }
10188   file = DECL_SOURCE_FILE (decl);
10189
10190   /* Complain if the field is deprecated and the file it was defined
10191      in isn't compiled at the same time the file which contains its
10192      use is */
10193   if (DECL_DEPRECATED (decl)
10194       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10195     {
10196       const char *the;
10197       switch (TREE_CODE (decl))
10198         {
10199         case FUNCTION_DECL:
10200           the = "method";
10201           break;
10202         case FIELD_DECL:
10203         case VAR_DECL:
10204           the = "field";
10205           break;
10206         case TYPE_DECL:
10207           parse_warning_context (wfl, "The class `%s' has been deprecated",
10208                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10209           return;
10210         default:
10211           abort ();
10212         }
10213       /* Don't issue a message if the context as been deprecated as a
10214          whole. */
10215       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10216         parse_warning_context
10217           (wfl, "The %s `%s' in class `%s' has been deprecated",
10218            the, lang_printable_name (decl, 0),
10219            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10220     }
10221 }
10222
10223 /* Returns 1 if class was declared in the current package, 0 otherwise */
10224
10225 static GTY(()) tree cicp_cache;
10226 static int
10227 class_in_current_package (tree class)
10228 {
10229   int qualified_flag;
10230   tree left;
10231
10232   if (cicp_cache == class)
10233     return 1;
10234
10235   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10236
10237   /* If the current package is empty and the name of CLASS is
10238      qualified, class isn't in the current package.  If there is a
10239      current package and the name of the CLASS is not qualified, class
10240      isn't in the current package */
10241   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10242     return 0;
10243
10244   /* If there is not package and the name of CLASS isn't qualified,
10245      they belong to the same unnamed package */
10246   if (!ctxp->package && !qualified_flag)
10247     return 1;
10248
10249   /* Compare the left part of the name of CLASS with the package name */
10250   breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10251   if (ctxp->package == left)
10252     {
10253       cicp_cache = class;
10254       return 1;
10255     }
10256   return 0;
10257 }
10258
10259 /* This function may generate code to access DECL from WHERE. This is
10260    done only if certain conditions meet.  */
10261
10262 static tree
10263 maybe_access_field (tree decl, tree where, tree type)
10264 {
10265   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10266       && !FIELD_STATIC (decl))
10267     decl = build_field_ref (where ? where : current_this,
10268                             (type ? type : DECL_CONTEXT (decl)),
10269                             DECL_NAME (decl));
10270   return decl;
10271 }
10272
10273 /* Build a method invocation, by patching PATCH. If non NULL
10274    and according to the situation, PRIMARY and WHERE may be
10275    used. IS_STATIC is set to 1 if the invoked function is static. */
10276
10277 static tree
10278 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10279                          int *is_static, tree *ret_decl)
10280 {
10281   tree wfl = TREE_OPERAND (patch, 0);
10282   tree args = TREE_OPERAND (patch, 1);
10283   tree name = EXPR_WFL_NODE (wfl);
10284   tree list;
10285   int is_static_flag = 0;
10286   int is_super_init = 0;
10287   tree this_arg = NULL_TREE;
10288   int is_array_clone_call = 0;
10289
10290   /* Should be overridden if everything goes well. Otherwise, if
10291      something fails, it should keep this value. It stop the
10292      evaluation of a bogus assignment. See java_complete_tree,
10293      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10294      evaluating an assignment */
10295   TREE_TYPE (patch) = error_mark_node;
10296
10297   /* Since lookup functions are messing with line numbers, save the
10298      context now.  */
10299   java_parser_context_save_global ();
10300
10301   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10302
10303   /* Resolution of qualified name, excluding constructors */
10304   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10305     {
10306       tree identifier, identifier_wfl, type, resolved;
10307       /* Extract the last IDENTIFIER of the qualified
10308          expression. This is a wfl and we will use it's location
10309          data during error report. */
10310       identifier_wfl = cut_identifier_in_qualified (wfl);
10311       identifier = EXPR_WFL_NODE (identifier_wfl);
10312
10313       /* Given the context, IDENTIFIER is syntactically qualified
10314          as a MethodName. We need to qualify what's before */
10315       qualify_ambiguous_name (wfl);
10316       resolved = resolve_field_access (wfl, NULL, NULL);
10317
10318       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10319          && FIELD_FINAL (resolved)
10320          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10321          && !flag_emit_class_files && !flag_emit_xref)
10322        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10323
10324       if (resolved == error_mark_node)
10325         PATCH_METHOD_RETURN_ERROR ();
10326
10327       type = GET_SKIP_TYPE (resolved);
10328       resolve_and_layout (type, NULL_TREE);
10329
10330       if (JPRIMITIVE_TYPE_P (type))
10331         {
10332           parse_error_context
10333             (identifier_wfl,
10334              "Can't invoke a method on primitive type `%s'",
10335              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10336           PATCH_METHOD_RETURN_ERROR ();
10337         }
10338
10339       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10340       args = nreverse (args);
10341
10342       /* We're resolving a call from a type */
10343       if (TREE_CODE (resolved) == TYPE_DECL)
10344         {
10345           if (CLASS_INTERFACE (resolved))
10346             {
10347               parse_error_context
10348                 (identifier_wfl,
10349                 "Can't make static reference to method `%s' in interface `%s'",
10350                  IDENTIFIER_POINTER (identifier),
10351                  IDENTIFIER_POINTER (name));
10352               PATCH_METHOD_RETURN_ERROR ();
10353             }
10354           if (list && !METHOD_STATIC (list))
10355             {
10356               char *fct_name = xstrdup (lang_printable_name (list, 0));
10357               parse_error_context
10358                 (identifier_wfl,
10359                  "Can't make static reference to method `%s %s' in class `%s'",
10360                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10361                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10362               free (fct_name);
10363               PATCH_METHOD_RETURN_ERROR ();
10364             }
10365         }
10366       else
10367         this_arg = primary = resolved;
10368
10369       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10370         is_array_clone_call = 1;
10371
10372       /* IDENTIFIER_WFL will be used to report any problem further */
10373       wfl = identifier_wfl;
10374     }
10375   /* Resolution of simple names, names generated after a primary: or
10376      constructors */
10377   else
10378     {
10379       tree class_to_search = NULL_TREE;
10380       int lc;                   /* Looking for Constructor */
10381
10382       /* We search constructor in their target class */
10383       if (CALL_CONSTRUCTOR_P (patch))
10384         {
10385           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10386             class_to_search = EXPR_WFL_NODE (wfl);
10387           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10388                    this_identifier_node)
10389             class_to_search = NULL_TREE;
10390           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10391                    super_identifier_node)
10392             {
10393               is_super_init = 1;
10394               if (CLASSTYPE_SUPER (current_class))
10395                 class_to_search =
10396                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10397               else
10398                 {
10399                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10400                   PATCH_METHOD_RETURN_ERROR ();
10401                 }
10402             }
10403
10404           /* Class to search is NULL if we're searching the current one */
10405           if (class_to_search)
10406             {
10407               class_to_search = resolve_and_layout (class_to_search, wfl);
10408
10409               if (!class_to_search)
10410                 {
10411                   parse_error_context
10412                     (wfl, "Class `%s' not found in type declaration",
10413                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10414                   PATCH_METHOD_RETURN_ERROR ();
10415                 }
10416
10417               /* Can't instantiate an abstract class, but we can
10418                  invoke it's constructor. It's use within the `new'
10419                  context is denied here. */
10420               if (CLASS_ABSTRACT (class_to_search)
10421                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10422                 {
10423                   parse_error_context
10424                     (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10425                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10426                   PATCH_METHOD_RETURN_ERROR ();
10427                 }
10428
10429               class_to_search = TREE_TYPE (class_to_search);
10430             }
10431           else
10432             class_to_search = current_class;
10433           lc = 1;
10434         }
10435       /* This is a regular search in the local class, unless an
10436          alternate class is specified. */
10437       else
10438         {
10439           if (where != NULL_TREE)
10440             class_to_search = where;
10441           else if (QUALIFIED_P (name))
10442             class_to_search = current_class;
10443           else
10444             {
10445               class_to_search = current_class;
10446
10447               for (;;)
10448                 {
10449                   if (has_method (class_to_search, name))
10450                     break;
10451                   if (! INNER_CLASS_TYPE_P (class_to_search))
10452                     {
10453                       parse_error_context (wfl,
10454                                            "No method named `%s' in scope",
10455                                            IDENTIFIER_POINTER (name));
10456                       PATCH_METHOD_RETURN_ERROR ();
10457                     }
10458                   class_to_search
10459                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10460                 }
10461             }
10462           lc = 0;
10463         }
10464
10465       /* NAME is a simple identifier or comes from a primary. Search
10466          in the class whose declaration contain the method being
10467          invoked. */
10468       resolve_and_layout (class_to_search, NULL_TREE);
10469
10470       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10471       /* Don't continue if no method were found, as the next statement
10472          can't be executed then. */
10473       if (!list)
10474         PATCH_METHOD_RETURN_ERROR ();
10475
10476       if (TYPE_ARRAY_P (class_to_search)
10477           && DECL_NAME (list) == get_identifier ("clone"))
10478         is_array_clone_call = 1;
10479
10480       /* Check for static reference if non static methods */
10481       if (check_for_static_method_reference (wfl, patch, list,
10482                                              class_to_search, primary))
10483         PATCH_METHOD_RETURN_ERROR ();
10484
10485       /* Check for inner classes creation from illegal contexts */
10486       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10487                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10488           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10489           && !DECL_INIT_P (current_function_decl))
10490         {
10491           parse_error_context
10492             (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10493              lang_printable_name (class_to_search, 0),
10494              (!current_this ? "" :
10495               "; an explicit one must be provided when creating this inner class"));
10496           PATCH_METHOD_RETURN_ERROR ();
10497         }
10498
10499       /* Non static methods are called with the current object extra
10500          argument. If patch a `new TYPE()', the argument is the value
10501          returned by the object allocator. If method is resolved as a
10502          primary, use the primary otherwise use the current THIS. */
10503       args = nreverse (args);
10504       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10505         {
10506           this_arg = primary ? primary : current_this;
10507
10508           /* If we're using an access method, things are different.
10509              There are two family of cases:
10510
10511              1) We're not generating bytecodes:
10512
10513              - LIST is non static. It's invocation is transformed from
10514                x(a1,...,an) into this$<n>.x(a1,....an).
10515              - LIST is static. It's invocation is transformed from
10516                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10517
10518              2) We're generating bytecodes:
10519
10520              - LIST is non static. It's invocation is transformed from
10521                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10522              - LIST is static. It's invocation is transformed from
10523                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10524
10525              Of course, this$<n> can be arbitrarily complex, ranging from
10526              this$0 (the immediate outer context) to
10527              access$0(access$0(...(this$0))).
10528
10529              maybe_use_access_method returns a nonzero value if the
10530              this_arg has to be moved into the (then generated) stub
10531              argument list. In the meantime, the selected function
10532              might have be replaced by a generated stub. */
10533           if (!primary &&
10534               maybe_use_access_method (is_super_init, &list, &this_arg))
10535             {
10536               args = tree_cons (NULL_TREE, this_arg, args);
10537               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10538             }
10539         }
10540     }
10541
10542   /* Merge point of all resolution schemes. If we have nothing, this
10543      is an error, already signaled */
10544   if (!list)
10545     PATCH_METHOD_RETURN_ERROR ();
10546
10547   /* Check accessibility, position the is_static flag, build and
10548      return the call */
10549   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10550                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10551                          NULL_TREE), from_super)
10552       /* Calls to clone() on array types are permitted as a special-case. */
10553       && !is_array_clone_call)
10554     {
10555       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10556       const char *const access =
10557         accessibility_string (get_access_flags_from_decl (list));
10558       const char *const klass =
10559         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10560       const char *const refklass =
10561         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10562       const char *const what = (DECL_CONSTRUCTOR_P (list)
10563                                 ? "constructor" : "method");
10564       /* FIXME: WFL yields the wrong message here but I don't know
10565          what else to use.  */
10566       parse_error_context (wfl,
10567                            "Can't access %s %s `%s.%s' from `%s'",
10568                            access, what, klass, fct_name, refklass);
10569       PATCH_METHOD_RETURN_ERROR ();
10570     }
10571
10572   /* Deprecation check: check whether the method being invoked or the
10573      instance-being-created's type are deprecated.  */
10574   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10575     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10576   check_deprecation (wfl, list);
10577
10578   /* If invoking a innerclass constructor, there are hidden parameters
10579      to pass */
10580   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10581       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10582     {
10583       /* And make sure we add the accessed local variables to be saved
10584          in field aliases. */
10585       args = build_alias_initializer_parameter_list
10586         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10587
10588       /* Secretly pass the current_this/primary as a second argument */
10589       if (primary || current_this)
10590         {
10591           tree extra_arg;
10592           tree this_type = (current_this ?
10593                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10594           /* Method's (list) enclosing context */
10595           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10596           /* If we have a primary, use it. */
10597           if (primary)
10598             extra_arg = primary;
10599           /* The current `this' is an inner class but isn't a direct
10600              enclosing context for the inner class we're trying to
10601              create. Build an access to the proper enclosing context
10602              and use it. */
10603           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10604                    && this_type != TREE_TYPE (mec))
10605             {
10606
10607               extra_arg = build_access_to_thisn (current_class,
10608                                                  TREE_TYPE (mec), 0);
10609               extra_arg = java_complete_tree (extra_arg);
10610             }
10611           /* Otherwise, just use the current `this' as an enclosing
10612              context. */
10613           else
10614             extra_arg = current_this;
10615           args = tree_cons (NULL_TREE, extra_arg, args);
10616         }
10617       else
10618         args = tree_cons (NULL_TREE, integer_zero_node, args);
10619     }
10620
10621   /* This handles the situation where a constructor invocation needs
10622      to have an enclosing context passed as a second parameter (the
10623      constructor is one of an inner class). */
10624   if ((is_super_init ||
10625        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10626       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10627     {
10628       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10629       tree extra_arg =
10630         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10631       extra_arg = java_complete_tree (extra_arg);
10632       args = tree_cons (NULL_TREE, extra_arg, args);
10633     }
10634
10635   is_static_flag = METHOD_STATIC (list);
10636   if (! is_static_flag && this_arg != NULL_TREE)
10637     args = tree_cons (NULL_TREE, this_arg, args);
10638
10639   /* In the context of an explicit constructor invocation, we can't
10640      invoke any method relying on `this'. Exceptions are: we're
10641      invoking a static function, primary exists and is not the current
10642      this, we're creating a new object. */
10643   if (ctxp->explicit_constructor_p
10644       && !is_static_flag
10645       && (!primary || primary == current_this)
10646       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10647     {
10648       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10649       PATCH_METHOD_RETURN_ERROR ();
10650     }
10651   java_parser_context_restore_global ();
10652   if (is_static)
10653     *is_static = is_static_flag;
10654   /* Sometimes, we want the decl of the selected method. Such as for
10655      EH checking */
10656   if (ret_decl)
10657     *ret_decl = list;
10658   patch = patch_invoke (patch, list, args);
10659
10660   /* Now is a good time to insert the call to finit$ */
10661   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10662     {
10663       tree finit_parms, finit_call;
10664
10665       /* Prepare to pass hidden parameters to finit$, if any. */
10666       finit_parms = build_alias_initializer_parameter_list
10667         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10668
10669       finit_call =
10670         build_method_invocation (build_wfl_node (finit_identifier_node),
10671                                  finit_parms);
10672
10673       /* Generate the code used to initialize fields declared with an
10674          initialization statement and build a compound statement along
10675          with the super constructor invocation. */
10676       CAN_COMPLETE_NORMALLY (patch) = 1;
10677       patch = build (COMPOUND_EXPR, void_type_node, patch,
10678                      java_complete_tree (finit_call));
10679     }
10680   return patch;
10681 }
10682
10683 /* Check that we're not trying to do a static reference to a method in
10684    non static method. Return 1 if it's the case, 0 otherwise. */
10685
10686 static int
10687 check_for_static_method_reference (tree wfl, tree node, tree method,
10688                                    tree where, tree primary)
10689 {
10690   if (METHOD_STATIC (current_function_decl)
10691       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10692     {
10693       char *fct_name = xstrdup (lang_printable_name (method, 0));
10694       parse_error_context
10695         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10696          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10697          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10698       free (fct_name);
10699       return 1;
10700     }
10701   return 0;
10702 }
10703
10704 /* Fix the invocation of *MDECL if necessary in the case of a
10705    invocation from an inner class. *THIS_ARG might be modified
10706    appropriately and an alternative access to *MDECL might be
10707    returned.  */
10708
10709 static int
10710 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10711 {
10712   tree ctx;
10713   tree md = *mdecl, ta = *this_arg;
10714   int to_return = 0;
10715   int non_static_context = !METHOD_STATIC (md);
10716
10717   if (is_super_init
10718       || DECL_CONTEXT (md) == current_class
10719       || !PURE_INNER_CLASS_TYPE_P (current_class)
10720       || DECL_FINIT_P (md)
10721       || DECL_INSTINIT_P (md))
10722     return 0;
10723
10724   /* If we're calling a method found in an enclosing class, generate
10725      what it takes to retrieve the right this. Don't do that if we're
10726      invoking a static method. Note that if MD's type is unrelated to
10727      CURRENT_CLASS, then the current this can be used. */
10728
10729   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10730     {
10731       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10732       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10733         {
10734           ta = build_current_thisn (current_class);
10735           ta = build_wfl_node (ta);
10736         }
10737       else
10738         {
10739           tree type = ctx;
10740           while (type)
10741             {
10742               maybe_build_thisn_access_method (type);
10743               if (inherits_from_p (type, DECL_CONTEXT (md)))
10744                 {
10745                   ta = build_access_to_thisn (ctx, type, 0);
10746                   break;
10747                 }
10748               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10749                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10750             }
10751         }
10752       ta = java_complete_tree (ta);
10753     }
10754
10755   /* We might have to use an access method to get to MD. We can
10756      break the method access rule as far as we're not generating
10757      bytecode */
10758   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10759     {
10760       md = build_outer_method_access_method (md);
10761       to_return = 1;
10762     }
10763
10764   *mdecl = md;
10765   *this_arg = ta;
10766
10767   /* Returning a nonzero value indicates we were doing a non static
10768      method invocation that is now a static invocation. It will have
10769      callee displace `this' to insert it in the regular argument
10770      list. */
10771   return (non_static_context && to_return);
10772 }
10773
10774 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10775    mode.  */
10776
10777 static tree
10778 patch_invoke (tree patch, tree method, tree args)
10779 {
10780   tree dtable, func;
10781   tree original_call, t, ta;
10782   tree check = NULL_TREE;
10783
10784   /* Last step for args: convert build-in types. If we're dealing with
10785      a new TYPE() type call, the first argument to the constructor
10786      isn't found in the incoming argument list, but delivered by
10787      `new' */
10788   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10789   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10790     t = TREE_CHAIN (t);
10791   for (ta = args; t != end_params_node && ta;
10792        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10793     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10794         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10795       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10796
10797   /* Resolve unresolved returned type issues */
10798   t = TREE_TYPE (TREE_TYPE (method));
10799   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10800     resolve_and_layout (TREE_TYPE (t), NULL);
10801
10802   if (flag_emit_class_files || flag_emit_xref)
10803     func = method;
10804   else
10805     {
10806       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10807         {
10808         case INVOKE_VIRTUAL:
10809           dtable = invoke_build_dtable (0, args);
10810           func = build_invokevirtual (dtable, method);
10811           break;
10812
10813         case INVOKE_NONVIRTUAL:
10814           /* If the object for the method call is null, we throw an
10815              exception.  We don't do this if the object is the current
10816              method's `this'.  In other cases we just rely on an
10817              optimization pass to eliminate redundant checks.  */
10818           if (TREE_VALUE (args) != current_this)
10819             {
10820               /* We use a save_expr here to make sure we only evaluate
10821                  the new `self' expression once.  */
10822               tree save_arg = save_expr (TREE_VALUE (args));
10823               TREE_VALUE (args) = save_arg;
10824               check = java_check_reference (save_arg, 1);
10825             }
10826           /* Fall through.  */
10827
10828         case INVOKE_SUPER:
10829         case INVOKE_STATIC:
10830           {
10831             tree signature = build_java_signature (TREE_TYPE (method));
10832             func = build_known_method_ref (method, TREE_TYPE (method),
10833                                            DECL_CONTEXT (method),
10834                                            signature, args);
10835           }
10836           break;
10837
10838         case INVOKE_INTERFACE:
10839           dtable = invoke_build_dtable (1, args);
10840           func = build_invokeinterface (dtable, method);
10841           break;
10842
10843         default:
10844           abort ();
10845         }
10846
10847       /* Ensure self_type is initialized, (invokestatic). FIXME */
10848       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10849     }
10850
10851   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10852   TREE_OPERAND (patch, 0) = func;
10853   TREE_OPERAND (patch, 1) = args;
10854   patch = check_for_builtin (method, patch);
10855   original_call = patch;
10856
10857   /* We're processing a `new TYPE ()' form. New is called and its
10858      returned value is the first argument to the constructor. We build
10859      a COMPOUND_EXPR and use saved expression so that the overall NEW
10860      expression value is a pointer to a newly created and initialized
10861      class. */
10862   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10863     {
10864       tree class = DECL_CONTEXT (method);
10865       tree c1, saved_new, size, new;
10866       tree alloc_node;
10867
10868       if (flag_emit_class_files || flag_emit_xref)
10869         {
10870           TREE_TYPE (patch) = build_pointer_type (class);
10871           return patch;
10872         }
10873       if (!TYPE_SIZE (class))
10874         safe_layout_class (class);
10875       size = size_in_bytes (class);
10876       alloc_node =
10877         (class_has_finalize_method (class) ? alloc_object_node
10878                                            : alloc_no_finalizer_node);
10879       new = build (CALL_EXPR, promote_type (class),
10880                      build_address_of (alloc_node),
10881                      build_tree_list (NULL_TREE, build_class_ref (class)),
10882                      NULL_TREE);
10883       saved_new = save_expr (new);
10884       c1 = build_tree_list (NULL_TREE, saved_new);
10885       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10886       TREE_OPERAND (original_call, 1) = c1;
10887       TREE_SET_CODE (original_call, CALL_EXPR);
10888       patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10889     }
10890
10891   /* If CHECK is set, then we are building a check to see if the object
10892      is NULL.  */
10893   if (check != NULL_TREE)
10894     {
10895       /* We have to call force_evaluation_order now because creating a
10896          COMPOUND_EXPR wraps the arg list in a way that makes it
10897          unrecognizable by force_evaluation_order later.  Yuk.  */
10898       patch = build (COMPOUND_EXPR, TREE_TYPE (patch), check,
10899                      force_evaluation_order (patch));
10900       TREE_SIDE_EFFECTS (patch) = 1;
10901     }
10902
10903   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10904      put it as the first expression of a COMPOUND_EXPR. The second
10905      expression being an empty statement to be later patched if
10906      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10907      the VALUE is the compound) in a hashtable and return a
10908      COMPOUND_EXPR built so that the result of the evaluation of the
10909      original PATCH node is returned. */
10910   if (STATIC_CLASS_INIT_OPT_P ()
10911       && current_function_decl && METHOD_STATIC (method))
10912     {
10913       tree list;
10914       tree fndecl = current_function_decl;
10915       /* We have to call force_evaluation_order now because creating a
10916          COMPOUND_EXPR wraps the arg list in a way that makes it
10917          unrecognizable by force_evaluation_order later.  Yuk.  */
10918       tree save = save_expr (force_evaluation_order (patch));
10919       tree type = TREE_TYPE (patch);
10920
10921       patch = build (COMPOUND_EXPR, type, save, empty_stmt_node);
10922       list = tree_cons (method, patch,
10923                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10924
10925       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10926
10927       patch = build (COMPOUND_EXPR, type, patch, save);
10928     }
10929
10930   return patch;
10931 }
10932
10933 static int
10934 invocation_mode (tree method, int super)
10935 {
10936   int access = get_access_flags_from_decl (method);
10937
10938   if (super)
10939     return INVOKE_SUPER;
10940
10941   if (access & ACC_STATIC)
10942     return INVOKE_STATIC;
10943
10944   /* We have to look for a constructor before we handle nonvirtual
10945      calls; otherwise the constructor will look nonvirtual.  */
10946   if (DECL_CONSTRUCTOR_P (method))
10947     return INVOKE_STATIC;
10948
10949   if (access & ACC_FINAL || access & ACC_PRIVATE)
10950     return INVOKE_NONVIRTUAL;
10951
10952   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10953     return INVOKE_NONVIRTUAL;
10954
10955   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10956     return INVOKE_INTERFACE;
10957
10958   return INVOKE_VIRTUAL;
10959 }
10960
10961 /* Retrieve a refined list of matching methods. It covers the step
10962    15.11.2 (Compile-Time Step 2) */
10963
10964 static tree
10965 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
10966 {
10967   tree atl = end_params_node;           /* Arg Type List */
10968   tree method, signature, list, node;
10969   const char *candidates;               /* Used for error report */
10970   char *dup;
10971
10972   /* Fix the arguments */
10973   for (node = arg_list; node; node = TREE_CHAIN (node))
10974     {
10975       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10976       /* Non primitive type may have to be resolved */
10977       if (!JPRIMITIVE_TYPE_P (current_arg))
10978         resolve_and_layout (current_arg, NULL_TREE);
10979       /* And promoted */
10980       if (TREE_CODE (current_arg) == RECORD_TYPE)
10981         current_arg = promote_type (current_arg);
10982       atl = tree_cons (NULL_TREE, current_arg, atl);
10983     }
10984
10985   /* Presto. If we're dealing with an anonymous class and a
10986      constructor call, generate the right constructor now, since we
10987      know the arguments' types. */
10988
10989   if (lc && ANONYMOUS_CLASS_P (class))
10990     {
10991       tree saved_current_class;
10992       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10993       saved_current_class = current_class;
10994       current_class = class;
10995       fix_constructors (mdecl);
10996       current_class = saved_current_class;
10997     }
10998
10999   /* Find all candidates and then refine the list, searching for the
11000      most specific method. */
11001   list = find_applicable_accessible_methods_list (lc, class, name, atl);
11002   list = find_most_specific_methods_list (list);
11003   if (list && !TREE_CHAIN (list))
11004     return TREE_VALUE (list);
11005
11006   /* Issue an error. List candidates if any. Candidates are listed
11007      only if accessible (non accessible methods may end-up here for
11008      the sake of a better error report). */
11009   candidates = NULL;
11010   if (list)
11011     {
11012       tree current;
11013       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
11014       for (current = list; current; current = TREE_CHAIN (current))
11015         {
11016           tree cm = TREE_VALUE (current);
11017           char string [4096];
11018           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
11019             continue;
11020           sprintf
11021             (string, "  `%s' in `%s'%s",
11022              get_printable_method_name (cm),
11023              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
11024              (TREE_CHAIN (current) ? "\n" : ""));
11025           obstack_grow (&temporary_obstack, string, strlen (string));
11026         }
11027       obstack_1grow (&temporary_obstack, '\0');
11028       candidates = obstack_finish (&temporary_obstack);
11029     }
11030   /* Issue the error message */
11031   method = make_node (FUNCTION_TYPE);
11032   TYPE_ARG_TYPES (method) = atl;
11033   signature = build_java_argument_signature (method);
11034   dup = xstrdup (lang_printable_name (class, 0));
11035   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
11036                        (lc ? "constructor" : "method"),
11037                        (lc ? dup : IDENTIFIER_POINTER (name)),
11038                        IDENTIFIER_POINTER (signature), dup,
11039                        (candidates ? candidates : ""));
11040   free (dup);
11041   return NULL_TREE;
11042 }
11043
11044 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
11045    when we're looking for a constructor. */
11046
11047 static tree
11048 find_applicable_accessible_methods_list (int lc, tree class, tree name,
11049                                          tree arglist)
11050 {
11051   static htab_t searched_classes;
11052   static int search_not_done = 0;
11053   tree list = NULL_TREE, all_list = NULL_TREE;
11054
11055   /* Check the hash table to determine if this class has been searched
11056      already. */
11057   if (searched_classes)
11058     {
11059       if (htab_find (searched_classes, class) != NULL)
11060         return NULL;
11061     }
11062   else
11063     {
11064       searched_classes = htab_create (10, htab_hash_pointer,
11065                                       htab_eq_pointer, NULL);
11066     }
11067
11068   search_not_done++;
11069   *htab_find_slot (searched_classes, class, INSERT) = class;
11070
11071   if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
11072     {
11073       load_class (class, 1);
11074       safe_layout_class (class);
11075     }
11076
11077   /* Search interfaces */
11078   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11079       && CLASS_INTERFACE (TYPE_NAME (class)))
11080     {
11081       int i, n;
11082       tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11083       search_applicable_methods_list (lc, TYPE_METHODS (class),
11084                                       name, arglist, &list, &all_list);
11085       n = TREE_VEC_LENGTH (basetype_vec);
11086       for (i = 1; i < n; i++)
11087         {
11088           tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11089           tree rlist;
11090
11091           rlist = find_applicable_accessible_methods_list (lc,  t, name,
11092                                                            arglist);
11093           list = chainon (rlist, list);
11094         }
11095     }
11096   /* Search classes */
11097   else
11098     {
11099       search_applicable_methods_list (lc, TYPE_METHODS (class),
11100                                       name, arglist, &list, &all_list);
11101
11102       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11103          that we only search in class. Note that we should have found
11104          something at this point. */
11105       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11106         {
11107           lc = 1;
11108           if (!list)
11109             abort ();
11110         }
11111
11112       /* We must search all interfaces of this class */
11113       if (!lc)
11114       {
11115         tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11116         int n = TREE_VEC_LENGTH (basetype_vec), i;
11117         for (i = 1; i < n; i++)
11118           {
11119             tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11120             if (t != object_type_node)
11121               {
11122                 tree rlist
11123                   = find_applicable_accessible_methods_list (lc, t,
11124                                                              name, arglist);
11125                 list = chainon (rlist, list);
11126               }
11127           }
11128       }
11129
11130       /* Search superclass */
11131       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11132         {
11133           tree rlist;
11134           class = CLASSTYPE_SUPER (class);
11135           rlist = find_applicable_accessible_methods_list (lc, class,
11136                                                            name, arglist);
11137           list = chainon (rlist, list);
11138         }
11139     }
11140
11141   search_not_done--;
11142
11143   /* We're done. Reset the searched classes list and finally search
11144      java.lang.Object if it wasn't searched already. */
11145   if (!search_not_done)
11146     {
11147       if (!lc
11148           && TYPE_METHODS (object_type_node)
11149           && htab_find (searched_classes, object_type_node) == NULL)
11150         {
11151           search_applicable_methods_list (lc,
11152                                           TYPE_METHODS (object_type_node),
11153                                           name, arglist, &list, &all_list);
11154         }
11155       htab_delete (searched_classes);
11156       searched_classes = NULL;
11157     }
11158
11159   /* Either return the list obtained or all selected (but
11160      inaccessible) methods for better error report. */
11161   return (!list ? all_list : list);
11162 }
11163
11164 /* Effectively search for the appropriate method in method */
11165
11166 static void
11167 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11168                                 tree *list, tree *all_list)
11169 {
11170   for (; method; method = TREE_CHAIN (method))
11171     {
11172       /* When dealing with constructor, stop here, otherwise search
11173          other classes */
11174       if (lc && !DECL_CONSTRUCTOR_P (method))
11175         continue;
11176       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11177                        || (DECL_NAME (method) != name)))
11178         continue;
11179
11180       if (argument_types_convertible (method, arglist))
11181         {
11182           /* Retain accessible methods only */
11183           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11184                                  method, NULL_TREE, 0))
11185             *list = tree_cons (NULL_TREE, method, *list);
11186           else
11187             /* Also retain all selected method here */
11188             *all_list = tree_cons (NULL_TREE, method, *list);
11189         }
11190     }
11191 }
11192
11193 /* 15.11.2.2 Choose the Most Specific Method */
11194
11195 static tree
11196 find_most_specific_methods_list (tree list)
11197 {
11198   int max = 0;
11199   int abstract, candidates;
11200   tree current, new_list = NULL_TREE;
11201   for (current = list; current; current = TREE_CHAIN (current))
11202     {
11203       tree method;
11204       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11205
11206       for (method = list; method; method = TREE_CHAIN (method))
11207         {
11208           tree method_v, current_v;
11209           /* Don't test a method against itself */
11210           if (method == current)
11211             continue;
11212
11213           method_v = TREE_VALUE (method);
11214           current_v = TREE_VALUE (current);
11215
11216           /* Compare arguments and location where methods where declared */
11217           if (argument_types_convertible (method_v, current_v))
11218             {
11219               if (valid_method_invocation_conversion_p
11220                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11221                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11222                       && enclosing_context_p (DECL_CONTEXT (method_v),
11223                                               DECL_CONTEXT (current_v))))
11224                 {
11225                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
11226                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11227                   max = (v > max ? v : max);
11228                 }
11229             }
11230         }
11231     }
11232
11233   /* Review the list and select the maximally specific methods */
11234   for (current = list, abstract = -1, candidates = -1;
11235        current; current = TREE_CHAIN (current))
11236     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11237       {
11238         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11239         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11240         candidates++;
11241       }
11242
11243   /* If we have several and they're all abstract, just pick the
11244      closest one. */
11245   if (candidates > 0 && candidates == abstract)
11246     {
11247       /* FIXME: merge the throws clauses.  There is no convenient way
11248          to do this in gcj right now, since ideally we'd like to
11249          introduce a new METHOD_DECL here, but that is really not
11250          possible.  */
11251       new_list = nreverse (new_list);
11252       TREE_CHAIN (new_list) = NULL_TREE;
11253       return new_list;
11254     }
11255
11256   /* We have several (we couldn't find a most specific), all but one
11257      are abstract, we pick the only non abstract one. */
11258   if (candidates > 0 && (candidates == abstract+1))
11259     {
11260       for (current = new_list; current; current = TREE_CHAIN (current))
11261         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11262           {
11263             TREE_CHAIN (current) = NULL_TREE;
11264             new_list = current;
11265           }
11266     }
11267
11268   /* If we can't find one, lower expectations and try to gather multiple
11269      maximally specific methods */
11270   while (!new_list && max)
11271     {
11272       while (--max > 0)
11273         {
11274           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11275             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11276         }
11277     }
11278
11279   return new_list;
11280 }
11281
11282 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11283    converted by method invocation conversion (5.3) to the type of the
11284    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11285    to change less often than M1. */
11286
11287 static GTY(()) tree m2_arg_value;
11288 static GTY(()) tree m2_arg_cache;
11289
11290 static int
11291 argument_types_convertible (tree m1, tree m2_or_arglist)
11292 {
11293   tree m1_arg, m2_arg;
11294
11295   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11296
11297   if (m2_arg_value == m2_or_arglist)
11298     m2_arg = m2_arg_cache;
11299   else
11300     {
11301       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11302          argument types */
11303       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11304         {
11305           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11306           if (!METHOD_STATIC (m2_or_arglist))
11307             m2_arg = TREE_CHAIN (m2_arg);
11308         }
11309       else
11310         m2_arg = m2_or_arglist;
11311
11312       m2_arg_value = m2_or_arglist;
11313       m2_arg_cache = m2_arg;
11314     }
11315
11316   while (m1_arg != end_params_node && m2_arg != end_params_node)
11317     {
11318       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11319       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11320                                                  TREE_VALUE (m2_arg)))
11321         break;
11322       m1_arg = TREE_CHAIN (m1_arg);
11323       m2_arg = TREE_CHAIN (m2_arg);
11324     }
11325   return m1_arg == end_params_node && m2_arg == end_params_node;
11326 }
11327
11328 /* Qualification routines */
11329
11330 /* Given a name x.y.z, look up x locally.  If it's found, save the
11331    decl.  If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11332    so that we later try and load the appropriate classes.  */
11333 static void
11334 qualify_ambiguous_name (tree id)
11335 {
11336   tree name, decl;
11337
11338   /* We inspect the first item of the qualification list.  As a sanity
11339      check, make sure that it is an identfier node.  */
11340   tree qual = EXPR_WFL_QUALIFICATION (id);
11341   tree qual_wfl = QUAL_WFL (qual);
11342
11343   if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11344     return;
11345
11346   name = EXPR_WFL_NODE (qual_wfl);
11347
11348   /* If we don't have an identifier, or we have a 'this' or 'super',
11349      then field access processing is all we need : there is nothing
11350      for us to do.  */
11351   if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11352       name == this_identifier_node ||
11353       name == super_identifier_node)
11354     return;
11355
11356   /* If name appears within the scope of a local variable declaration
11357      or parameter declaration, or is a field within an enclosing
11358      class, then it is an expression name.  Save the decl and let
11359      resolve_field_access do it's work.  */
11360   if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11361       (decl = lookup_field_wrapper (current_class, name)))
11362     {
11363       QUAL_RESOLUTION (qual) = decl;
11364       return;
11365     }
11366
11367   /* If name is a known class name (either declared or imported), mark
11368      us as a type name.  */
11369   if ((decl = resolve_and_layout (name, NULL_TREE)))
11370     {
11371       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11372       QUAL_RESOLUTION (qual) = decl;
11373     }
11374
11375   /* Check here that NAME isn't declared by more than one
11376      type-import-on-demand declaration of the compilation unit
11377      containing NAME. FIXME */
11378
11379   /* We couldn't find a declaration for the name.  Assume for now that
11380      we have a qualified class name that needs to be loaded from an
11381      external class file.  */
11382   else
11383     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11384
11385   /* Propagate the qualification across other components of the
11386      qualified name */
11387   for (qual = TREE_CHAIN (qual); qual;
11388        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11389     {
11390       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11391         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11392     }
11393
11394   /* Store the global qualification for the ambiguous part of ID back
11395      into ID fields */
11396   if (RESOLVE_TYPE_NAME_P (qual_wfl))
11397     RESOLVE_TYPE_NAME_P (id) = 1;
11398   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11399     RESOLVE_PACKAGE_NAME_P (id) = 1;
11400 }
11401
11402 static int
11403 breakdown_qualified (tree *left, tree *right, tree source)
11404 {
11405   char *p, *base;
11406   int l = IDENTIFIER_LENGTH (source);
11407
11408   base = alloca (l + 1);
11409   memcpy (base, IDENTIFIER_POINTER (source), l + 1);
11410
11411   /* Breakdown NAME into REMAINDER . IDENTIFIER.  */
11412   p = base + l - 1;
11413   while (*p != '.' && p != base)
11414     p--;
11415
11416   /* We didn't find a '.'. Return an error.  */
11417   if (p == base)
11418     return 1;
11419
11420   *p = '\0';
11421   if (right)
11422     *right = get_identifier (p+1);
11423   *left = get_identifier (base);
11424
11425   return 0;
11426 }
11427
11428 /* Return TRUE if two classes are from the same package. */
11429
11430 static int
11431 in_same_package (tree name1, tree name2)
11432 {
11433   tree tmp;
11434   tree pkg1;
11435   tree pkg2;
11436
11437   if (TREE_CODE (name1) == TYPE_DECL)
11438     name1 = DECL_NAME (name1);
11439   if (TREE_CODE (name2) == TYPE_DECL)
11440     name2 = DECL_NAME (name2);
11441
11442   if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
11443     /* One in empty package. */
11444     return 0;
11445
11446   if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
11447     /* Both in empty package. */
11448     return 1;
11449
11450   breakdown_qualified (&pkg1, &tmp, name1);
11451   breakdown_qualified (&pkg2, &tmp, name2);
11452
11453   return (pkg1 == pkg2);
11454 }
11455
11456 /* Patch tree nodes in a function body. When a BLOCK is found, push
11457    local variable decls if present.
11458    Same as java_complete_lhs, but does resolve static finals to values. */
11459
11460 static tree
11461 java_complete_tree (tree node)
11462 {
11463   node = java_complete_lhs (node);
11464   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11465       && DECL_INITIAL (node) != NULL_TREE
11466       && !flag_emit_xref)
11467     {
11468       tree value = fold_constant_for_init (node, node);
11469       if (value != NULL_TREE)
11470         return value;
11471     }
11472   return node;
11473 }
11474
11475 static tree
11476 java_stabilize_reference (tree node)
11477 {
11478   if (TREE_CODE (node) == COMPOUND_EXPR)
11479     {
11480       tree op0 = TREE_OPERAND (node, 0);
11481       tree op1 = TREE_OPERAND (node, 1);
11482       TREE_OPERAND (node, 0) = save_expr (op0);
11483       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11484       return node;
11485     }
11486   return stabilize_reference (node);
11487 }
11488
11489 /* Patch tree nodes in a function body. When a BLOCK is found, push
11490    local variable decls if present.
11491    Same as java_complete_tree, but does not resolve static finals to values. */
11492
11493 static tree
11494 java_complete_lhs (tree node)
11495 {
11496   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11497   int flag;
11498
11499   /* CONVERT_EXPR always has its type set, even though it needs to be
11500      worked out. */
11501   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11502     return node;
11503
11504   /* The switch block implements cases processing container nodes
11505      first.  Contained nodes are always written back. Leaves come
11506      next and return a value. */
11507   switch (TREE_CODE (node))
11508     {
11509     case BLOCK:
11510
11511       /* 1- Block section.
11512          Set the local values on decl names so we can identify them
11513          faster when they're referenced. At that stage, identifiers
11514          are legal so we don't check for declaration errors. */
11515       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11516         {
11517           DECL_CONTEXT (cn) = current_function_decl;
11518           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11519         }
11520       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11521           CAN_COMPLETE_NORMALLY (node) = 1;
11522       else
11523         {
11524           tree stmt = BLOCK_EXPR_BODY (node);
11525           tree *ptr;
11526           int error_seen = 0;
11527           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11528             {
11529               /* Re-order from (((A; B); C); ...; Z) to
11530                  (A; (B; (C ; (...; Z)))).
11531                  This makes it easier to scan the statements left-to-right
11532                  without using recursion (which might overflow the stack
11533                  if the block has many statements. */
11534               for (;;)
11535                 {
11536                   tree left = TREE_OPERAND (stmt, 0);
11537                   if (TREE_CODE (left) != COMPOUND_EXPR)
11538                     break;
11539                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11540                   TREE_OPERAND (left, 1) = stmt;
11541                   stmt = left;
11542                 }
11543               BLOCK_EXPR_BODY (node) = stmt;
11544             }
11545
11546           /* Now do the actual complete, without deep recursion for
11547              long blocks. */
11548           ptr = &BLOCK_EXPR_BODY (node);
11549           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11550                  && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
11551             {
11552               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11553               tree *next = &TREE_OPERAND (*ptr, 1);
11554               TREE_OPERAND (*ptr, 0) = cur;
11555               if (cur == empty_stmt_node)
11556                 {
11557                   /* Optimization;  makes it easier to detect empty bodies.
11558                      Most useful for <clinit> with all-constant initializer. */
11559                   *ptr = *next;
11560                   continue;
11561                 }
11562               if (TREE_CODE (cur) == ERROR_MARK)
11563                 error_seen++;
11564               else if (! CAN_COMPLETE_NORMALLY (cur))
11565                 {
11566                   wfl_op2 = *next;
11567                   for (;;)
11568                     {
11569                       if (TREE_CODE (wfl_op2) == BLOCK)
11570                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11571                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11572                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11573                       else
11574                         break;
11575                     }
11576                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11577                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11578                     unreachable_stmt_error (*ptr);
11579                 }
11580               if (TREE_TYPE (*ptr) == NULL_TREE)
11581                 TREE_TYPE (*ptr) = void_type_node;
11582               ptr = next;
11583             }
11584           *ptr = java_complete_tree (*ptr);
11585
11586           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11587             return error_mark_node;
11588           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11589         }
11590       /* Turn local bindings to null */
11591       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11592         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11593
11594       TREE_TYPE (node) = void_type_node;
11595       break;
11596
11597       /* 2- They are expressions but ultimately deal with statements */
11598
11599     case THROW_EXPR:
11600       wfl_op1 = TREE_OPERAND (node, 0);
11601       COMPLETE_CHECK_OP_0 (node);
11602       /* 14.19 A throw statement cannot complete normally. */
11603       CAN_COMPLETE_NORMALLY (node) = 0;
11604       return patch_throw_statement (node, wfl_op1);
11605
11606     case SYNCHRONIZED_EXPR:
11607       wfl_op1 = TREE_OPERAND (node, 0);
11608       return patch_synchronized_statement (node, wfl_op1);
11609
11610     case TRY_EXPR:
11611       return patch_try_statement (node);
11612
11613     case TRY_FINALLY_EXPR:
11614       COMPLETE_CHECK_OP_0 (node);
11615       COMPLETE_CHECK_OP_1 (node);
11616       /* Reduce try/finally nodes with an empty try block.  */
11617       if (TREE_OPERAND (node, 0) == empty_stmt_node
11618           || BLOCK_EMPTY_P (TREE_OPERAND (node, 0)))
11619         return TREE_OPERAND (node, 1);
11620       /* Likewise for an empty finally block.  */
11621       if (TREE_OPERAND (node, 1) == empty_stmt_node
11622           || BLOCK_EMPTY_P (TREE_OPERAND (node, 1)))
11623         return TREE_OPERAND (node, 0);
11624       CAN_COMPLETE_NORMALLY (node)
11625         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11626            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11627       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11628       return node;
11629
11630     case LABELED_BLOCK_EXPR:
11631       PUSH_LABELED_BLOCK (node);
11632       if (LABELED_BLOCK_BODY (node))
11633         COMPLETE_CHECK_OP_1 (node);
11634       TREE_TYPE (node) = void_type_node;
11635       POP_LABELED_BLOCK ();
11636
11637       if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
11638         {
11639           LABELED_BLOCK_BODY (node) = NULL_TREE;
11640           CAN_COMPLETE_NORMALLY (node) = 1;
11641         }
11642       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11643         CAN_COMPLETE_NORMALLY (node) = 1;
11644       return node;
11645
11646     case EXIT_BLOCK_EXPR:
11647       /* We don't complete operand 1, because it's the return value of
11648          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11649       return patch_bc_statement (node);
11650
11651     case CASE_EXPR:
11652       cn = java_complete_tree (TREE_OPERAND (node, 0));
11653       if (cn == error_mark_node)
11654         return cn;
11655
11656       /* First, the case expression must be constant. Values of final
11657          fields are accepted. */
11658       cn = fold (cn);
11659       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11660           && JDECL_P (TREE_OPERAND (cn, 1))
11661           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11662           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11663         {
11664           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11665                                        TREE_OPERAND (cn, 1));
11666         }
11667       /* Accept final locals too. */
11668       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn)
11669                && DECL_INITIAL (cn))
11670         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11671
11672       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11673         {
11674           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11675           parse_error_context (node, "Constant expression required");
11676           return error_mark_node;
11677         }
11678
11679       nn = ctxp->current_loop;
11680
11681       /* It must be assignable to the type of the switch expression. */
11682       if (!try_builtin_assignconv (NULL_TREE,
11683                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11684         {
11685           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11686           parse_error_context
11687             (wfl_operator,
11688              "Incompatible type for case. Can't convert `%s' to `int'",
11689              lang_printable_name (TREE_TYPE (cn), 0));
11690           return error_mark_node;
11691         }
11692
11693       cn = fold (convert (int_type_node, cn));
11694       TREE_CONSTANT_OVERFLOW (cn) = 0;
11695       CAN_COMPLETE_NORMALLY (cn) = 1;
11696
11697       /* Save the label on a list so that we can later check for
11698          duplicates.  */
11699       case_label_list = tree_cons (node, cn, case_label_list);
11700
11701       /* Multiple instance of a case label bearing the same value is
11702          checked later. The case expression is all right so far. */
11703       if (TREE_CODE (cn) == VAR_DECL)
11704         cn = DECL_INITIAL (cn);
11705       TREE_OPERAND (node, 0) = cn;
11706       TREE_TYPE (node) = void_type_node;
11707       CAN_COMPLETE_NORMALLY (node) = 1;
11708       TREE_SIDE_EFFECTS (node) = 1;
11709       break;
11710
11711     case DEFAULT_EXPR:
11712       nn = ctxp->current_loop;
11713       /* Only one default label is allowed per switch statement */
11714       if (SWITCH_HAS_DEFAULT (nn))
11715         {
11716           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11717           parse_error_context (wfl_operator,
11718                                "Duplicate case label: `default'");
11719           return error_mark_node;
11720         }
11721       else
11722         SWITCH_HAS_DEFAULT (nn) = 1;
11723       TREE_TYPE (node) = void_type_node;
11724       TREE_SIDE_EFFECTS (node) = 1;
11725       CAN_COMPLETE_NORMALLY (node) = 1;
11726       break;
11727
11728     case SWITCH_EXPR:
11729     case LOOP_EXPR:
11730       PUSH_LOOP (node);
11731       /* Check whether the loop was enclosed in a labeled
11732          statement. If not, create one, insert the loop in it and
11733          return the node */
11734       nn = patch_loop_statement (node);
11735
11736       /* Anyways, walk the body of the loop */
11737       if (TREE_CODE (node) == LOOP_EXPR)
11738         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11739       /* Switch statement: walk the switch expression and the cases */
11740       else
11741         node = patch_switch_statement (node);
11742
11743       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11744         nn = error_mark_node;
11745       else
11746         {
11747           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11748           /* If we returned something different, that's because we
11749              inserted a label. Pop the label too. */
11750           if (nn != node)
11751             {
11752               if (CAN_COMPLETE_NORMALLY (node))
11753                 CAN_COMPLETE_NORMALLY (nn) = 1;
11754               POP_LABELED_BLOCK ();
11755             }
11756         }
11757       POP_LOOP ();
11758       return nn;
11759
11760     case EXIT_EXPR:
11761       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11762       return patch_exit_expr (node);
11763
11764     case COND_EXPR:
11765       /* Condition */
11766       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11767       if (TREE_OPERAND (node, 0) == error_mark_node)
11768         return error_mark_node;
11769       /* then-else branches */
11770       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11771       if (TREE_OPERAND (node, 1) == error_mark_node)
11772         return error_mark_node;
11773       TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11774       if (TREE_OPERAND (node, 2) == error_mark_node)
11775         return error_mark_node;
11776       return patch_if_else_statement (node);
11777       break;
11778
11779     case CONDITIONAL_EXPR:
11780       /* Condition */
11781       wfl_op1 = TREE_OPERAND (node, 0);
11782       COMPLETE_CHECK_OP_0 (node);
11783       wfl_op2 = TREE_OPERAND (node, 1);
11784       COMPLETE_CHECK_OP_1 (node);
11785       wfl_op3 = TREE_OPERAND (node, 2);
11786       COMPLETE_CHECK_OP_2 (node);
11787       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11788
11789       /* 3- Expression section */
11790     case COMPOUND_EXPR:
11791       wfl_op2 = TREE_OPERAND (node, 1);
11792       TREE_OPERAND (node, 0) = nn =
11793         java_complete_tree (TREE_OPERAND (node, 0));
11794       if (wfl_op2 == empty_stmt_node)
11795         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11796       else
11797         {
11798           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11799             {
11800               /* An unreachable condition in a do-while statement
11801                  is *not* (technically) an unreachable statement. */
11802               nn = wfl_op2;
11803               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11804                 nn = EXPR_WFL_NODE (nn);
11805               /* NN can be NULL_TREE exactly when UPDATE is, in
11806                  finish_for_loop.  */
11807               if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11808                 {
11809                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11810                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11811                     {
11812                       /* Perhaps this warning should have an
11813                          associated flag.  The code being compiled is
11814                          pedantically correct, but useless.  */
11815                       parse_warning_context (wfl_operator,
11816                                              "Unreachable statement");
11817                     }
11818                   else
11819                     parse_error_context (wfl_operator,
11820                                          "Unreachable statement");
11821                 }
11822             }
11823           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11824           if (TREE_OPERAND (node, 1) == error_mark_node)
11825             return error_mark_node;
11826           /* Even though we might allow the case where the first
11827              operand doesn't return normally, we still should compute
11828              CAN_COMPLETE_NORMALLY correctly.  */
11829           CAN_COMPLETE_NORMALLY (node)
11830             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11831                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11832         }
11833       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11834       break;
11835
11836     case RETURN_EXPR:
11837       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11838       return patch_return (node);
11839
11840     case EXPR_WITH_FILE_LOCATION:
11841       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11842           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11843         {
11844           tree wfl = node;
11845           node = resolve_expression_name (node, NULL);
11846           if (node == error_mark_node)
11847             return node;
11848           /* Keep line number information somewhere were it doesn't
11849              disrupt the completion process. */
11850           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11851             {
11852               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11853               TREE_OPERAND (node, 1) = wfl;
11854             }
11855           CAN_COMPLETE_NORMALLY (node) = 1;
11856         }
11857       else
11858         {
11859           tree body;
11860           int save_lineno = input_line;
11861           input_line = EXPR_WFL_LINENO (node);
11862           body = java_complete_tree (EXPR_WFL_NODE (node));
11863           input_line = save_lineno;
11864           EXPR_WFL_NODE (node) = body;
11865           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11866           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11867           if (body == empty_stmt_node || TREE_CONSTANT (body))
11868             {
11869               /* Makes it easier to constant fold, detect empty bodies. */
11870               return body;
11871             }
11872           if (body == error_mark_node)
11873             {
11874               /* Its important for the evaluation of assignment that
11875                  this mark on the TREE_TYPE is propagated. */
11876               TREE_TYPE (node) = error_mark_node;
11877               return error_mark_node;
11878             }
11879           else
11880             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11881
11882         }
11883       break;
11884
11885     case NEW_ARRAY_EXPR:
11886       /* Patch all the dimensions */
11887       flag = 0;
11888       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11889         {
11890           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11891           tree dim = convert (int_type_node,
11892                               java_complete_tree (TREE_VALUE (cn)));
11893           if (dim == error_mark_node)
11894             {
11895               flag = 1;
11896               continue;
11897             }
11898           else
11899             {
11900               TREE_VALUE (cn) = dim;
11901               /* Setup the location of the current dimension, for
11902                  later error report. */
11903               TREE_PURPOSE (cn) =
11904                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11905               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11906             }
11907         }
11908       /* They complete the array creation expression, if no errors
11909          were found. */
11910       CAN_COMPLETE_NORMALLY (node) = 1;
11911       return (flag ? error_mark_node
11912               : force_evaluation_order (patch_newarray (node)));
11913
11914     case NEW_ANONYMOUS_ARRAY_EXPR:
11915       /* Create the array type if necessary. */
11916       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11917         {
11918           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11919           if (!(type = resolve_type_during_patch (type)))
11920             return error_mark_node;
11921           type = build_array_from_name (type, NULL_TREE,
11922                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11923           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11924         }
11925       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11926                                    ANONYMOUS_ARRAY_INITIALIZER (node));
11927       if (node == error_mark_node)
11928         return error_mark_node;
11929       CAN_COMPLETE_NORMALLY (node) = 1;
11930       return node;
11931
11932     case NEW_CLASS_EXPR:
11933     case CALL_EXPR:
11934       /* Complete function's argument(s) first */
11935       if (complete_function_arguments (node))
11936         return error_mark_node;
11937       else
11938         {
11939           tree decl, wfl = TREE_OPERAND (node, 0);
11940           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11941           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11942                            super_identifier_node);
11943           tree arguments;
11944           int location = EXPR_WFL_LINECOL (node);
11945
11946           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11947                                           from_super, 0, &decl);
11948           if (node == error_mark_node)
11949             return error_mark_node;
11950
11951           if (TREE_CODE (node) == CALL_EXPR
11952               && TREE_OPERAND (node, 1) != NULL_TREE)
11953             arguments = TREE_VALUE (TREE_OPERAND (node, 1));
11954           else
11955             arguments = NULL_TREE;
11956           check_thrown_exceptions (location, decl, arguments);
11957           /* If we call this(...), register signature and positions */
11958           if (in_this)
11959             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11960               tree_cons (wfl, decl,
11961                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
11962           CAN_COMPLETE_NORMALLY (node) = 1;
11963           return force_evaluation_order (node);
11964         }
11965
11966     case MODIFY_EXPR:
11967       /* Save potential wfls */
11968       wfl_op1 = TREE_OPERAND (node, 0);
11969       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11970
11971       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11972           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11973           && DECL_INITIAL (nn) != NULL_TREE)
11974         {
11975           tree value;
11976
11977           value = fold_constant_for_init (nn, nn);
11978
11979           /* When we have a primitype type, or a string and we're not
11980              emitting a class file, we actually don't want to generate
11981              anything for the assignment. */
11982           if (value != NULL_TREE &&
11983               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
11984                (TREE_TYPE (value) == string_ptr_type_node &&
11985                 ! flag_emit_class_files)))
11986             {
11987               /* Prepare node for patch_assignment */
11988               TREE_OPERAND (node, 1) = value;
11989               /* Call patch assignment to verify the assignment */
11990               if (patch_assignment (node, wfl_op1) == error_mark_node)
11991                 return error_mark_node;
11992               /* Set DECL_INITIAL properly (a conversion might have
11993                  been decided by patch_assignment) and return the
11994                  empty statement. */
11995               else
11996                 {
11997                   tree patched = patch_string (TREE_OPERAND (node, 1));
11998                   if (patched)
11999                     DECL_INITIAL (nn) = patched;
12000                   else
12001                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12002                   DECL_FIELD_FINAL_IUD (nn) = 1;
12003                   return empty_stmt_node;
12004                 }
12005             }
12006           if (! flag_emit_class_files)
12007             DECL_INITIAL (nn) = NULL_TREE;
12008         }
12009       wfl_op2 = TREE_OPERAND (node, 1);
12010
12011       if (TREE_OPERAND (node, 0) == error_mark_node)
12012         return error_mark_node;
12013
12014       flag = COMPOUND_ASSIGN_P (wfl_op2);
12015       if (flag)
12016         {
12017           /* This might break when accessing outer field from inner
12018              class. TESTME, FIXME */
12019           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
12020
12021           /* Hand stabilize the lhs on both places */
12022           TREE_OPERAND (node, 0) = lvalue;
12023           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
12024             (flag_emit_class_files ? lvalue : save_expr (lvalue));
12025
12026           /* 15.25.2.a: Left hand is not an array access. FIXME */
12027           /* Now complete the RHS. We write it back later on. */
12028           nn = java_complete_tree (TREE_OPERAND (node, 1));
12029
12030           if ((cn = patch_string (nn)))
12031             nn = cn;
12032
12033           /* The last part of the rewrite for E1 op= E2 is to have
12034              E1 = (T)(E1 op E2), with T being the type of E1. */
12035           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
12036                                                TREE_TYPE (lvalue), nn));
12037
12038           /* If the assignment is compound and has reference type,
12039              then ensure the LHS has type String and nothing else.  */
12040           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
12041               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
12042             parse_error_context (wfl_op2,
12043                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
12044                                  lang_printable_name (TREE_TYPE (lvalue), 0));
12045
12046           /* 15.25.2.b: Left hand is an array access. FIXME */
12047         }
12048
12049       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12050          function to complete this RHS. Note that a NEW_ARRAY_INIT
12051          might have been already fully expanded if created as a result
12052          of processing an anonymous array initializer. We avoid doing
12053          the operation twice by testing whether the node already bears
12054          a type. */
12055       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12056         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12057                                    TREE_OPERAND (node, 1));
12058       /* Otherwise we simply complete the RHS */
12059       else
12060         nn = java_complete_tree (TREE_OPERAND (node, 1));
12061
12062       if (nn == error_mark_node)
12063         return error_mark_node;
12064
12065       /* Write back the RHS as we evaluated it. */
12066       TREE_OPERAND (node, 1) = nn;
12067
12068       /* In case we're handling = with a String as a RHS, we need to
12069          produce a String out of the RHS (it might still be a
12070          STRING_CST or a StringBuffer at this stage */
12071       if ((nn = patch_string (TREE_OPERAND (node, 1))))
12072         TREE_OPERAND (node, 1) = nn;
12073
12074       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12075                                         TREE_OPERAND (node, 1))))
12076         {
12077           /* We return error_mark_node if outer_field_access_fix
12078              detects we write into a final. */
12079           if (nn == error_mark_node)
12080             return error_mark_node;
12081           node = nn;
12082         }
12083       else
12084         {
12085           node = patch_assignment (node, wfl_op1);
12086           if (node == error_mark_node)
12087             return error_mark_node;
12088           /* Reorganize the tree if necessary. */
12089           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12090                        || JSTRING_P (TREE_TYPE (node))))
12091             node = java_refold (node);
12092         }
12093
12094       /* Seek to set DECL_INITIAL to a proper value, since it might have
12095          undergone a conversion in patch_assignment. We do that only when
12096          it's necessary to have DECL_INITIAL properly set. */
12097       nn = TREE_OPERAND (node, 0);
12098       if (TREE_CODE (nn) == VAR_DECL
12099           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12100           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12101           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12102               || TREE_TYPE (nn) == string_ptr_type_node))
12103         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12104
12105       CAN_COMPLETE_NORMALLY (node) = 1;
12106       return node;
12107
12108     case MULT_EXPR:
12109     case PLUS_EXPR:
12110     case MINUS_EXPR:
12111     case LSHIFT_EXPR:
12112     case RSHIFT_EXPR:
12113     case URSHIFT_EXPR:
12114     case BIT_AND_EXPR:
12115     case BIT_XOR_EXPR:
12116     case BIT_IOR_EXPR:
12117     case TRUNC_MOD_EXPR:
12118     case TRUNC_DIV_EXPR:
12119     case RDIV_EXPR:
12120     case TRUTH_ANDIF_EXPR:
12121     case TRUTH_ORIF_EXPR:
12122     case EQ_EXPR:
12123     case NE_EXPR:
12124     case GT_EXPR:
12125     case GE_EXPR:
12126     case LT_EXPR:
12127     case LE_EXPR:
12128       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12129          knows how to handle those cases. */
12130       wfl_op1 = TREE_OPERAND (node, 0);
12131       wfl_op2 = TREE_OPERAND (node, 1);
12132
12133       CAN_COMPLETE_NORMALLY (node) = 1;
12134       /* Don't complete string nodes if dealing with the PLUS operand. */
12135       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12136         {
12137           nn = java_complete_tree (wfl_op1);
12138           if (nn == error_mark_node)
12139             return error_mark_node;
12140
12141           TREE_OPERAND (node, 0) = nn;
12142         }
12143       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12144         {
12145           nn = java_complete_tree (wfl_op2);
12146           if (nn == error_mark_node)
12147             return error_mark_node;
12148
12149           TREE_OPERAND (node, 1) = nn;
12150         }
12151       return patch_binop (node, wfl_op1, wfl_op2);
12152
12153     case INSTANCEOF_EXPR:
12154       wfl_op1 = TREE_OPERAND (node, 0);
12155       COMPLETE_CHECK_OP_0 (node);
12156       if (flag_emit_xref)
12157         {
12158           TREE_TYPE (node) = boolean_type_node;
12159           return node;
12160         }
12161       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12162
12163     case UNARY_PLUS_EXPR:
12164     case NEGATE_EXPR:
12165     case TRUTH_NOT_EXPR:
12166     case BIT_NOT_EXPR:
12167     case PREDECREMENT_EXPR:
12168     case PREINCREMENT_EXPR:
12169     case POSTDECREMENT_EXPR:
12170     case POSTINCREMENT_EXPR:
12171     case CONVERT_EXPR:
12172       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12173          how to handle those cases. */
12174       wfl_op1 = TREE_OPERAND (node, 0);
12175       CAN_COMPLETE_NORMALLY (node) = 1;
12176       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12177       if (TREE_OPERAND (node, 0) == error_mark_node)
12178         return error_mark_node;
12179       node = patch_unaryop (node, wfl_op1);
12180       CAN_COMPLETE_NORMALLY (node) = 1;
12181       break;
12182
12183     case ARRAY_REF:
12184       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12185          how to handle those cases. */
12186       wfl_op1 = TREE_OPERAND (node, 0);
12187       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12188       if (TREE_OPERAND (node, 0) == error_mark_node)
12189         return error_mark_node;
12190       if (!flag_emit_class_files && !flag_emit_xref)
12191         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12192       /* The same applies to wfl_op2 */
12193       wfl_op2 = TREE_OPERAND (node, 1);
12194       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12195       if (TREE_OPERAND (node, 1) == error_mark_node)
12196         return error_mark_node;
12197       if (!flag_emit_class_files && !flag_emit_xref)
12198         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12199       return patch_array_ref (node);
12200
12201     case RECORD_TYPE:
12202       return node;;
12203
12204     case COMPONENT_REF:
12205       /* The first step in the re-write of qualified name handling.  FIXME.
12206          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12207       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12208       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12209         {
12210           tree name = TREE_OPERAND (node, 1);
12211           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12212           if (field == NULL_TREE)
12213             {
12214               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12215               return error_mark_node;
12216             }
12217           if (! FIELD_STATIC (field))
12218             {
12219               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12220               return error_mark_node;
12221             }
12222           return field;
12223         }
12224       else
12225         abort ();
12226       break;
12227
12228     case THIS_EXPR:
12229       /* Can't use THIS in a static environment */
12230       if (!current_this)
12231         {
12232           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12233           parse_error_context (wfl_operator,
12234                                "Keyword `this' used outside allowed context");
12235           TREE_TYPE (node) = error_mark_node;
12236           return error_mark_node;
12237         }
12238       if (ctxp->explicit_constructor_p)
12239         {
12240           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12241           parse_error_context
12242             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12243           TREE_TYPE (node) = error_mark_node;
12244           return error_mark_node;
12245         }
12246       return current_this;
12247
12248     case CLASS_LITERAL:
12249       CAN_COMPLETE_NORMALLY (node) = 1;
12250       node = patch_incomplete_class_ref (node);
12251       if (node == error_mark_node)
12252         return error_mark_node;
12253       break;
12254
12255     default:
12256       CAN_COMPLETE_NORMALLY (node) = 1;
12257       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12258          and it's time to turn it into the appropriate String object */
12259       if ((nn = patch_string (node)))
12260         node = nn;
12261       else
12262         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12263     }
12264   return node;
12265 }
12266
12267 /* Complete function call's argument. Return a nonzero value is an
12268    error was found.  */
12269
12270 static int
12271 complete_function_arguments (tree node)
12272 {
12273   int flag = 0;
12274   tree cn;
12275
12276   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12277   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12278     {
12279       tree wfl = TREE_VALUE (cn), parm, temp;
12280       parm = java_complete_tree (wfl);
12281
12282       if (parm == error_mark_node)
12283         {
12284           flag = 1;
12285           continue;
12286         }
12287       /* If have a string literal that we haven't transformed yet or a
12288          crafted string buffer, as a result of use of the the String
12289          `+' operator. Build `parm.toString()' and expand it. */
12290       if ((temp = patch_string (parm)))
12291         parm = temp;
12292
12293       TREE_VALUE (cn) = parm;
12294     }
12295   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12296   return flag;
12297 }
12298
12299 /* Sometimes (for loops and variable initialized during their
12300    declaration), we want to wrap a statement around a WFL and turn it
12301    debugable.  */
12302
12303 static tree
12304 build_debugable_stmt (int location, tree stmt)
12305 {
12306   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12307     {
12308       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12309       EXPR_WFL_LINECOL (stmt) = location;
12310     }
12311   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12312   return stmt;
12313 }
12314
12315 static tree
12316 build_expr_block (tree body, tree decls)
12317
12318 {
12319   tree node = make_node (BLOCK);
12320   BLOCK_EXPR_DECLS (node) = decls;
12321   BLOCK_EXPR_BODY (node) = body;
12322   if (body)
12323     TREE_TYPE (node) = TREE_TYPE (body);
12324   TREE_SIDE_EFFECTS (node) = 1;
12325   return node;
12326 }
12327
12328 /* Create a new function block and link it appropriately to current
12329    function block chain */
12330
12331 static tree
12332 enter_block (void)
12333 {
12334   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12335
12336   /* Link block B supercontext to the previous block. The current
12337      function DECL is used as supercontext when enter_a_block is called
12338      for the first time for a given function. The current function body
12339      (DECL_FUNCTION_BODY) is set to be block B.  */
12340
12341   tree fndecl = current_function_decl;
12342
12343   if (!fndecl) {
12344     BLOCK_SUPERCONTEXT (b) = current_static_block;
12345     current_static_block = b;
12346   }
12347
12348   else if (!DECL_FUNCTION_BODY (fndecl))
12349     {
12350       BLOCK_SUPERCONTEXT (b) = fndecl;
12351       DECL_FUNCTION_BODY (fndecl) = b;
12352     }
12353   else
12354     {
12355       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12356       DECL_FUNCTION_BODY (fndecl) = b;
12357     }
12358   return b;
12359 }
12360
12361 /* Exit a block by changing the current function body
12362    (DECL_FUNCTION_BODY) to the current block super context, only if
12363    the block being exited isn't the method's top level one.  */
12364
12365 static tree
12366 exit_block (void)
12367 {
12368   tree b;
12369   if (current_function_decl)
12370     {
12371       b = DECL_FUNCTION_BODY (current_function_decl);
12372       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12373         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12374     }
12375   else
12376     {
12377       b = current_static_block;
12378
12379       if (BLOCK_SUPERCONTEXT (b))
12380         current_static_block = BLOCK_SUPERCONTEXT (b);
12381     }
12382   return b;
12383 }
12384
12385 /* Lookup for NAME in the nested function's blocks, all the way up to
12386    the current toplevel one. It complies with Java's local variable
12387    scoping rules.  */
12388
12389 static tree
12390 lookup_name_in_blocks (tree name)
12391 {
12392   tree b = GET_CURRENT_BLOCK (current_function_decl);
12393
12394   while (b != current_function_decl)
12395     {
12396       tree current;
12397
12398       /* Paranoid sanity check. To be removed */
12399       if (TREE_CODE (b) != BLOCK)
12400         abort ();
12401
12402       for (current = BLOCK_EXPR_DECLS (b); current;
12403            current = TREE_CHAIN (current))
12404         if (DECL_NAME (current) == name)
12405           return current;
12406       b = BLOCK_SUPERCONTEXT (b);
12407     }
12408   return NULL_TREE;
12409 }
12410
12411 static void
12412 maybe_absorb_scoping_blocks (void)
12413 {
12414   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12415     {
12416       tree b = exit_block ();
12417       java_method_add_stmt (current_function_decl, b);
12418       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12419     }
12420 }
12421
12422 \f
12423 /* This section of the source is reserved to build_* functions that
12424    are building incomplete tree nodes and the patch_* functions that
12425    are completing them.  */
12426
12427 /* Wrap a non WFL node around a WFL.  */
12428
12429 static tree
12430 build_wfl_wrap (tree node, int location)
12431 {
12432   tree wfl, node_to_insert = node;
12433
12434   /* We want to process THIS . xxx symbolically, to keep it consistent
12435      with the way we're processing SUPER. A THIS from a primary as a
12436      different form than a SUPER. Turn THIS into something symbolic */
12437   if (TREE_CODE (node) == THIS_EXPR)
12438     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12439   else
12440     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12441
12442   EXPR_WFL_LINECOL (wfl) = location;
12443   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12444   return wfl;
12445 }
12446
12447 /* Build a super() constructor invocation. Returns empty_stmt_node if
12448    we're currently dealing with the class java.lang.Object. */
12449
12450 static tree
12451 build_super_invocation (tree mdecl)
12452 {
12453   if (DECL_CONTEXT (mdecl) == object_type_node)
12454     return empty_stmt_node;
12455   else
12456     {
12457       tree super_wfl = build_wfl_node (super_identifier_node);
12458       tree a = NULL_TREE, t;
12459       /* If we're dealing with an anonymous class, pass the arguments
12460          of the crafted constructor along. */
12461       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12462         {
12463           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12464           for (; t != end_params_node; t = TREE_CHAIN (t))
12465             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12466         }
12467       return build_method_invocation (super_wfl, a);
12468     }
12469 }
12470
12471 /* Build a SUPER/THIS qualified method invocation.  */
12472
12473 static tree
12474 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12475                                        int lloc, int rloc)
12476 {
12477   tree invok;
12478   tree wfl =
12479     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12480   EXPR_WFL_LINECOL (wfl) = lloc;
12481   invok = build_method_invocation (name, args);
12482   return make_qualified_primary (wfl, invok, rloc);
12483 }
12484
12485 /* Build an incomplete CALL_EXPR node. */
12486
12487 static tree
12488 build_method_invocation (tree name, tree args)
12489 {
12490   tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12491   TREE_SIDE_EFFECTS (call) = 1;
12492   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12493   return call;
12494 }
12495
12496 /* Build an incomplete new xxx(...) node. */
12497
12498 static tree
12499 build_new_invocation (tree name, tree args)
12500 {
12501   tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12502   TREE_SIDE_EFFECTS (call) = 1;
12503   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12504   return call;
12505 }
12506
12507 /* Build an incomplete assignment expression. */
12508
12509 static tree
12510 build_assignment (int op, int op_location, tree lhs, tree rhs)
12511 {
12512   tree assignment;
12513   /* Build the corresponding binop if we deal with a Compound
12514      Assignment operator. Mark the binop sub-tree as part of a
12515      Compound Assignment expression */
12516   if (op != ASSIGN_TK)
12517     {
12518       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12519       COMPOUND_ASSIGN_P (rhs) = 1;
12520     }
12521   assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12522   TREE_SIDE_EFFECTS (assignment) = 1;
12523   EXPR_WFL_LINECOL (assignment) = op_location;
12524   return assignment;
12525 }
12526
12527 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12528    the buffer.  This is used only for string conversion.  */
12529 static char *
12530 string_convert_int_cst (tree node)
12531 {
12532   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12533   static char buffer[21];
12534
12535   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12536   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12537   char *p = buffer + sizeof (buffer);
12538   int neg = 0;
12539
12540   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12541                                   << (HOST_BITS_PER_WIDE_INT - 1));
12542
12543   *--p = '\0';
12544
12545   /* If negative, note the fact and negate the value.  */
12546   if ((hi & hibit))
12547     {
12548       lo = ~lo;
12549       hi = ~hi;
12550       if (++lo == 0)
12551         ++hi;
12552       neg = 1;
12553     }
12554
12555   /* Divide by 10 until there are no bits left.  */
12556   do
12557     {
12558       unsigned HOST_WIDE_INT acc = 0;
12559       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12560       unsigned int i;
12561
12562       /* Use long division to compute the result and the remainder.  */
12563       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12564         {
12565           /* Shift a bit into accumulator.  */
12566           acc <<= 1;
12567           if ((hi & hibit))
12568             acc |= 1;
12569
12570           /* Shift the value.  */
12571           hi <<= 1;
12572           if ((lo & hibit))
12573             hi |= 1;
12574           lo <<= 1;
12575
12576           /* Shift the correct bit into the result.  */
12577           outhi <<= 1;
12578           if ((outlo & hibit))
12579             outhi |= 1;
12580           outlo <<= 1;
12581           if (acc >= 10)
12582             {
12583               acc -= 10;
12584               outlo |= 1;
12585             }
12586         }
12587
12588       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12589       *--p = '\060' + acc;
12590
12591       hi = outhi;
12592       lo = outlo;
12593     }
12594   while (hi || lo);
12595
12596   if (neg)
12597     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12598
12599   return p;
12600 }
12601
12602 /* Print an INTEGER_CST node in a static buffer, and return the
12603    buffer.  This is used only for error handling.  */
12604 char *
12605 print_int_node (tree node)
12606 {
12607   static char buffer [80];
12608   if (TREE_CONSTANT_OVERFLOW (node))
12609     sprintf (buffer, "<overflow>");
12610
12611   if (TREE_INT_CST_HIGH (node) == 0)
12612     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12613              TREE_INT_CST_LOW (node));
12614   else if (TREE_INT_CST_HIGH (node) == -1
12615            && TREE_INT_CST_LOW (node) != 0)
12616     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12617              -TREE_INT_CST_LOW (node));
12618   else
12619     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12620              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12621
12622   return buffer;
12623 }
12624
12625 \f
12626 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12627    context.  */
12628
12629 /* 15.25 Assignment operators. */
12630
12631 static tree
12632 patch_assignment (tree node, tree wfl_op1)
12633 {
12634   tree rhs = TREE_OPERAND (node, 1);
12635   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12636   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12637   int error_found = 0;
12638   int lvalue_from_array = 0;
12639   int is_return = 0;
12640
12641   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12642
12643   /* Lhs can be a named variable */
12644   if (JDECL_P (lvalue))
12645     {
12646       lhs_type = TREE_TYPE (lvalue);
12647     }
12648   /* Or Lhs can be an array access. */
12649   else if (TREE_CODE (lvalue) == ARRAY_REF)
12650     {
12651       lhs_type = TREE_TYPE (lvalue);
12652       lvalue_from_array = 1;
12653     }
12654   /* Or a field access */
12655   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12656     lhs_type = TREE_TYPE (lvalue);
12657   /* Or a function return slot */
12658   else if (TREE_CODE (lvalue) == RESULT_DECL)
12659     {
12660       /* If the return type is an integral type, then we create the
12661          RESULT_DECL with a promoted type, but we need to do these
12662          checks against the unpromoted type to ensure type safety.  So
12663          here we look at the real type, not the type of the decl we
12664          are modifying.  */
12665       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12666       is_return = 1;
12667     }
12668   /* Otherwise, we might want to try to write into an optimized static
12669      final, this is an of a different nature, reported further on. */
12670   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12671            && resolve_expression_name (wfl_op1, &llvalue))
12672     {
12673       lhs_type = TREE_TYPE (lvalue);
12674     }
12675   else
12676     {
12677       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12678       error_found = 1;
12679     }
12680
12681   rhs_type = TREE_TYPE (rhs);
12682
12683   /* 5.1 Try the assignment conversion for builtin type. */
12684   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12685
12686   /* 5.2 If it failed, try a reference conversion */
12687   if (!new_rhs)
12688     new_rhs = try_reference_assignconv (lhs_type, rhs);
12689
12690   /* 15.25.2 If we have a compound assignment, convert RHS into the
12691      type of the LHS */
12692   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12693     new_rhs = convert (lhs_type, rhs);
12694
12695   /* Explicit cast required. This is an error */
12696   if (!new_rhs)
12697     {
12698       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12699       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12700       tree wfl;
12701       char operation [32];      /* Max size known */
12702
12703       /* If the assignment is part of a declaration, we use the WFL of
12704          the declared variable to point out the error and call it a
12705          declaration problem. If the assignment is a genuine =
12706          operator, we call is a operator `=' problem, otherwise we
12707          call it an assignment problem. In both of these last cases,
12708          we use the WFL of the operator to indicate the error. */
12709
12710       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12711         {
12712           wfl = wfl_op1;
12713           strcpy (operation, "declaration");
12714         }
12715       else
12716         {
12717           wfl = wfl_operator;
12718           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12719             strcpy (operation, "assignment");
12720           else if (is_return)
12721             strcpy (operation, "`return'");
12722           else
12723             strcpy (operation, "`='");
12724         }
12725
12726       if (!valid_cast_to_p (rhs_type, lhs_type))
12727         parse_error_context
12728           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12729            operation, t1, t2);
12730       else
12731         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12732                              operation, t1, t2);
12733       free (t1); free (t2);
12734       error_found = 1;
12735     }
12736
12737   if (error_found)
12738     return error_mark_node;
12739
12740   /* If we're processing a `return' statement, promote the actual type
12741      to the promoted type.  */
12742   if (is_return)
12743     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12744
12745   /* 10.10: Array Store Exception runtime check */
12746   if (!flag_emit_class_files
12747       && !flag_emit_xref
12748       && lvalue_from_array
12749       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12750     {
12751       tree array, store_check, base, index_expr;
12752
12753       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12754       new_rhs = save_expr (new_rhs);
12755
12756       /* Get the INDIRECT_REF. */
12757       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12758       /* Get the array pointer expr. */
12759       array = TREE_OPERAND (array, 0);
12760       store_check = build_java_arraystore_check (array, new_rhs);
12761
12762       index_expr = TREE_OPERAND (lvalue, 1);
12763
12764       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12765         {
12766           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12767              happen before the store check, so prepare to insert the store
12768              check within the second operand of the existing COMPOUND_EXPR. */
12769           base = index_expr;
12770         }
12771       else
12772         base = lvalue;
12773
12774       index_expr = TREE_OPERAND (base, 1);
12775       TREE_OPERAND (base, 1) = build (COMPOUND_EXPR, TREE_TYPE (index_expr),
12776                                       store_check, index_expr);
12777     }
12778
12779   /* Final locals can be used as case values in switch
12780      statement. Prepare them for this eventuality. */
12781   if (TREE_CODE (lvalue) == VAR_DECL
12782       && DECL_FINAL (lvalue)
12783       && TREE_CONSTANT (new_rhs)
12784       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12785       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12786       )
12787     {
12788       TREE_CONSTANT (lvalue) = 1;
12789       DECL_INITIAL (lvalue) = new_rhs;
12790     }
12791
12792   /* Copy the rhs if it's a reference.  */
12793   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12794     {
12795       switch (TREE_CODE (new_rhs))
12796         {
12797         case ARRAY_REF:
12798         case INDIRECT_REF:
12799         case COMPONENT_REF:
12800           /* Transform a = foo.bar
12801              into a = { int tmp; tmp = foo.bar; tmp; ).
12802              We need to ensure that if a read from memory fails
12803              because of a NullPointerException, a destination variable
12804              will remain unchanged.  An explicit temporary does what
12805              we need.
12806
12807              If flag_check_references is set, this is unnecessary
12808              because we'll check each reference before doing any
12809              reads.  If optimize is not set the result will never be
12810              written to a stack slot that contains the LHS.  */
12811           {
12812             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12813                                    TREE_TYPE (new_rhs));
12814             tree block = make_node (BLOCK);
12815             tree assignment
12816               = build (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12817             DECL_CONTEXT (tmp) = current_function_decl;
12818             TREE_TYPE (block) = TREE_TYPE (new_rhs);
12819             BLOCK_VARS (block) = tmp;
12820             BLOCK_EXPR_BODY (block)
12821               = build (COMPOUND_EXPR, TREE_TYPE (new_rhs), assignment, tmp);
12822             TREE_SIDE_EFFECTS (block) = 1;
12823             new_rhs = block;
12824           }
12825           break;
12826         default:
12827           break;
12828         }
12829     }
12830
12831   TREE_OPERAND (node, 0) = lvalue;
12832   TREE_OPERAND (node, 1) = new_rhs;
12833   TREE_TYPE (node) = lhs_type;
12834   return node;
12835 }
12836
12837 /* Check that type SOURCE can be cast into type DEST. If the cast
12838    can't occur at all, return NULL; otherwise, return a possibly
12839    modified rhs.  */
12840
12841 static tree
12842 try_reference_assignconv (tree lhs_type, tree rhs)
12843 {
12844   tree new_rhs = NULL_TREE;
12845   tree rhs_type = TREE_TYPE (rhs);
12846
12847   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12848     {
12849       /* `null' may be assigned to any reference type */
12850       if (rhs == null_pointer_node)
12851         new_rhs = null_pointer_node;
12852       /* Try the reference assignment conversion */
12853       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12854         new_rhs = rhs;
12855       /* This is a magic assignment that we process differently */
12856       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12857         new_rhs = rhs;
12858     }
12859   return new_rhs;
12860 }
12861
12862 /* Check that RHS can be converted into LHS_TYPE by the assignment
12863    conversion (5.2), for the cases of RHS being a builtin type. Return
12864    NULL_TREE if the conversion fails or if because RHS isn't of a
12865    builtin type. Return a converted RHS if the conversion is possible.  */
12866
12867 static tree
12868 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12869 {
12870   tree new_rhs = NULL_TREE;
12871   tree rhs_type = TREE_TYPE (rhs);
12872
12873   /* Handle boolean specially.  */
12874   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12875       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12876     {
12877       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12878           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12879         new_rhs = rhs;
12880     }
12881
12882   /* 5.1.1 Try Identity Conversion,
12883      5.1.2 Try Widening Primitive Conversion */
12884   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12885     new_rhs = convert (lhs_type, rhs);
12886
12887   /* Try a narrowing primitive conversion (5.1.3):
12888        - expression is a constant expression of type byte, short, char,
12889          or int, AND
12890        - variable is byte, short or char AND
12891        - The value of the expression is representable in the type of the
12892          variable */
12893   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12894             || rhs_type == char_type_node || rhs_type == int_type_node)
12895             && TREE_CONSTANT (rhs)
12896            && (lhs_type == byte_type_node || lhs_type == char_type_node
12897                || lhs_type == short_type_node))
12898     {
12899       if (int_fits_type_p (rhs, lhs_type))
12900         new_rhs = convert (lhs_type, rhs);
12901       else if (wfl_op1)         /* Might be called with a NULL */
12902         parse_warning_context
12903           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12904            print_int_node (rhs), lang_printable_name (lhs_type, 0));
12905       /* Reported a warning that will turn into an error further
12906          down, so we don't return */
12907     }
12908
12909   return new_rhs;
12910 }
12911
12912 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12913    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12914    0 is the conversion test fails.  This implements parts the method
12915    invocation conversion (5.3).  */
12916
12917 static int
12918 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
12919 {
12920   /* 5.1.1: This is the identity conversion part. */
12921   if (lhs_type == rhs_type)
12922     return 1;
12923
12924   /* Reject non primitive types and boolean conversions.  */
12925   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12926     return 0;
12927
12928   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12929      than a char can't be converted into a char. Short can't too, but
12930      the < test below takes care of that */
12931   if (lhs_type == char_type_node && rhs_type == byte_type_node)
12932     return 0;
12933
12934   /* Accept all promoted type here. Note, we can't use <= in the test
12935      below, because we still need to bounce out assignments of short
12936      to char and the likes */
12937   if (lhs_type == int_type_node
12938       && (rhs_type == promoted_byte_type_node
12939           || rhs_type == promoted_short_type_node
12940           || rhs_type == promoted_char_type_node
12941           || rhs_type == promoted_boolean_type_node))
12942     return 1;
12943
12944   /* From here, an integral is widened if its precision is smaller
12945      than the precision of the LHS or if the LHS is a floating point
12946      type, or the RHS is a float and the RHS a double. */
12947   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12948        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12949       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12950       || (rhs_type == float_type_node && lhs_type == double_type_node))
12951     return 1;
12952
12953   return 0;
12954 }
12955
12956 /* Check that something of SOURCE type can be assigned or cast to
12957    something of DEST type at runtime. Return 1 if the operation is
12958    valid, 0 otherwise. If CAST is set to 1, we're treating the case
12959    were SOURCE is cast into DEST, which borrows a lot of the
12960    assignment check. */
12961
12962 static int
12963 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
12964 {
12965   /* SOURCE or DEST might be null if not from a declared entity. */
12966   if (!source || !dest)
12967     return 0;
12968   if (JNULLP_TYPE_P (source))
12969     return 1;
12970   if (TREE_CODE (source) == POINTER_TYPE)
12971     source = TREE_TYPE (source);
12972   if (TREE_CODE (dest) == POINTER_TYPE)
12973     dest = TREE_TYPE (dest);
12974
12975   /* If source and dest are being compiled from bytecode, they may need to
12976      be loaded. */
12977   if (CLASS_P (source) && !CLASS_LOADED_P (source))
12978     {
12979       load_class (source, 1);
12980       safe_layout_class (source);
12981     }
12982   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
12983     {
12984       load_class (dest, 1);
12985       safe_layout_class (dest);
12986     }
12987
12988   /* Case where SOURCE is a class type */
12989   if (TYPE_CLASS_P (source))
12990     {
12991       if (TYPE_CLASS_P (dest))
12992         return  (source == dest
12993                  || inherits_from_p (source, dest)
12994                  || (cast && inherits_from_p (dest, source)));
12995       if (TYPE_INTERFACE_P (dest))
12996         {
12997           /* If doing a cast and SOURCE is final, the operation is
12998              always correct a compile time (because even if SOURCE
12999              does not implement DEST, a subclass of SOURCE might). */
13000           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
13001             return 1;
13002           /* Otherwise, SOURCE must implement DEST */
13003           return interface_of_p (dest, source);
13004         }
13005       /* DEST is an array, cast permitted if SOURCE is of Object type */
13006       return (cast && source == object_type_node ? 1 : 0);
13007     }
13008   if (TYPE_INTERFACE_P (source))
13009     {
13010       if (TYPE_CLASS_P (dest))
13011         {
13012           /* If not casting, DEST must be the Object type */
13013           if (!cast)
13014             return dest == object_type_node;
13015           /* We're doing a cast. The cast is always valid is class
13016              DEST is not final, otherwise, DEST must implement SOURCE */
13017           else if (!CLASS_FINAL (TYPE_NAME (dest)))
13018             return 1;
13019           else
13020             return interface_of_p (source, dest);
13021         }
13022       if (TYPE_INTERFACE_P (dest))
13023         {
13024           /* If doing a cast, then if SOURCE and DEST contain method
13025              with the same signature but different return type, then
13026              this is a (compile time) error */
13027           if (cast)
13028             {
13029               tree method_source, method_dest;
13030               tree source_type;
13031               tree source_sig;
13032               tree source_name;
13033               for (method_source = TYPE_METHODS (source); method_source;
13034                    method_source = TREE_CHAIN (method_source))
13035                 {
13036                   source_sig =
13037                     build_java_argument_signature (TREE_TYPE (method_source));
13038                   source_type = TREE_TYPE (TREE_TYPE (method_source));
13039                   source_name = DECL_NAME (method_source);
13040                   for (method_dest = TYPE_METHODS (dest);
13041                        method_dest; method_dest = TREE_CHAIN (method_dest))
13042                     if (source_sig ==
13043                         build_java_argument_signature (TREE_TYPE (method_dest))
13044                         && source_name == DECL_NAME (method_dest)
13045                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
13046                       return 0;
13047                 }
13048               return 1;
13049             }
13050           else
13051             return source == dest || interface_of_p (dest, source);
13052         }
13053       else
13054         {
13055           /* Array */
13056           return (cast
13057                   && (DECL_NAME (TYPE_NAME (source))
13058                       == java_lang_cloneable_identifier_node
13059                       || (DECL_NAME (TYPE_NAME (source))
13060                           == java_io_serializable_identifier_node)));
13061         }
13062     }
13063   if (TYPE_ARRAY_P (source))
13064     {
13065       if (TYPE_CLASS_P (dest))
13066         return dest == object_type_node;
13067       /* Can't cast an array to an interface unless the interface is
13068          java.lang.Cloneable or java.io.Serializable.  */
13069       if (TYPE_INTERFACE_P (dest))
13070         return (DECL_NAME (TYPE_NAME (dest))
13071                 == java_lang_cloneable_identifier_node
13072                 || (DECL_NAME (TYPE_NAME (dest))
13073                     == java_io_serializable_identifier_node));
13074       else                      /* Arrays */
13075         {
13076           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13077           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13078
13079           /* In case of severe errors, they turn out null */
13080           if (!dest_element_type || !source_element_type)
13081             return 0;
13082           if (source_element_type == dest_element_type)
13083             return 1;
13084           return valid_ref_assignconv_cast_p (source_element_type,
13085                                               dest_element_type, cast);
13086         }
13087       return 0;
13088     }
13089   return 0;
13090 }
13091
13092 static int
13093 valid_cast_to_p (tree source, tree dest)
13094 {
13095   if (TREE_CODE (source) == POINTER_TYPE)
13096     source = TREE_TYPE (source);
13097   if (TREE_CODE (dest) == POINTER_TYPE)
13098     dest = TREE_TYPE (dest);
13099
13100   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13101     return valid_ref_assignconv_cast_p (source, dest, 1);
13102
13103   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13104     return 1;
13105
13106   else if (TREE_CODE (source) == BOOLEAN_TYPE
13107            && TREE_CODE (dest) == BOOLEAN_TYPE)
13108     return 1;
13109
13110   return 0;
13111 }
13112
13113 static tree
13114 do_unary_numeric_promotion (tree arg)
13115 {
13116   tree type = TREE_TYPE (arg);
13117   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13118       || TREE_CODE (type) == CHAR_TYPE)
13119     arg = convert (int_type_node, arg);
13120   return arg;
13121 }
13122
13123 /* Return a nonzero value if SOURCE can be converted into DEST using
13124    the method invocation conversion rule (5.3).  */
13125 static int
13126 valid_method_invocation_conversion_p (tree dest, tree source)
13127 {
13128   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13129            && valid_builtin_assignconv_identity_widening_p (dest, source))
13130           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13131               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13132               && valid_ref_assignconv_cast_p (source, dest, 0)));
13133 }
13134
13135 /* Build an incomplete binop expression. */
13136
13137 static tree
13138 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13139 {
13140   tree binop = build (op, NULL_TREE, op1, op2);
13141   TREE_SIDE_EFFECTS (binop) = 1;
13142   /* Store the location of the operator, for better error report. The
13143      string of the operator will be rebuild based on the OP value. */
13144   EXPR_WFL_LINECOL (binop) = op_location;
13145   return binop;
13146 }
13147
13148 /* Build the string of the operator retained by NODE. If NODE is part
13149    of a compound expression, add an '=' at the end of the string. This
13150    function is called when an error needs to be reported on an
13151    operator. The string is returned as a pointer to a static character
13152    buffer. */
13153
13154 static char *
13155 operator_string (tree node)
13156 {
13157 #define BUILD_OPERATOR_STRING(S)                                        \
13158   {                                                                     \
13159     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13160     return buffer;                                                      \
13161   }
13162
13163   static char buffer [10];
13164   switch (TREE_CODE (node))
13165     {
13166     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13167     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13168     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13169     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13170     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13171     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13172     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13173     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13174     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13175     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13176     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13177     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13178     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13179     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13180     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13181     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13182     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13183     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13184     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13185     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13186     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13187     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13188     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13189     case PREINCREMENT_EXPR:     /* Fall through */
13190     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13191     case PREDECREMENT_EXPR:     /* Fall through */
13192     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13193     default:
13194       internal_error ("unregistered operator %s",
13195                       tree_code_name [TREE_CODE (node)]);
13196     }
13197   return NULL;
13198 #undef BUILD_OPERATOR_STRING
13199 }
13200
13201 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13202
13203 static int
13204 java_decl_equiv (tree var_acc1, tree var_acc2)
13205 {
13206   if (JDECL_P (var_acc1))
13207     return (var_acc1 == var_acc2);
13208
13209   return (TREE_CODE (var_acc1) == COMPONENT_REF
13210           && TREE_CODE (var_acc2) == COMPONENT_REF
13211           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13212              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13213           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13214 }
13215
13216 /* Return a nonzero value if CODE is one of the operators that can be
13217    used in conjunction with the `=' operator in a compound assignment.  */
13218
13219 static int
13220 binop_compound_p (enum tree_code code)
13221 {
13222   int i;
13223   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13224     if (binop_lookup [i] == code)
13225       break;
13226
13227   return i < BINOP_COMPOUND_CANDIDATES;
13228 }
13229
13230 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13231
13232 static tree
13233 java_refold (tree t)
13234 {
13235   tree c, b, ns, decl;
13236
13237   if (TREE_CODE (t) != MODIFY_EXPR)
13238     return t;
13239
13240   c = TREE_OPERAND (t, 1);
13241   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13242          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13243          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13244     return t;
13245
13246   /* Now the left branch of the binary operator. */
13247   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13248   if (! (b && TREE_CODE (b) == NOP_EXPR
13249          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13250     return t;
13251
13252   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13253   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13254          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13255     return t;
13256
13257   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13258   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13259       /* It's got to be the an equivalent decl */
13260       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13261     {
13262       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13263       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13264       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13265       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13266       /* Change the right part of the BINOP_EXPR */
13267       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13268     }
13269
13270   return t;
13271 }
13272
13273 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13274    errors but we modify NODE so that it contains the type computed
13275    according to the expression, when it's fixed. Otherwise, we write
13276    error_mark_node as the type. It allows us to further the analysis
13277    of remaining nodes and detects more errors in certain cases.  */
13278
13279 static tree
13280 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13281 {
13282   tree op1 = TREE_OPERAND (node, 0);
13283   tree op2 = TREE_OPERAND (node, 1);
13284   tree op1_type = TREE_TYPE (op1);
13285   tree op2_type = TREE_TYPE (op2);
13286   tree prom_type = NULL_TREE, cn;
13287   enum tree_code code = TREE_CODE (node);
13288
13289   /* If 1, tell the routine that we have to return error_mark_node
13290      after checking for the initialization of the RHS */
13291   int error_found = 0;
13292
13293   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13294
13295   /* If either op<n>_type are NULL, this might be early signs of an
13296      error situation, unless it's too early to tell (in case we're
13297      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13298      correctly so the error can be later on reported accurately. */
13299   if (! (code == PLUS_EXPR || code == NE_EXPR
13300          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13301     {
13302       tree n;
13303       if (! op1_type)
13304         {
13305           n = java_complete_tree (op1);
13306           op1_type = TREE_TYPE (n);
13307         }
13308       if (! op2_type)
13309         {
13310           n = java_complete_tree (op2);
13311           op2_type = TREE_TYPE (n);
13312         }
13313     }
13314
13315   switch (code)
13316     {
13317     /* 15.16 Multiplicative operators */
13318     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13319     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13320     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13321     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13322       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13323         {
13324           if (!JNUMERIC_TYPE_P (op1_type))
13325             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13326           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13327             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13328           TREE_TYPE (node) = error_mark_node;
13329           error_found = 1;
13330           break;
13331         }
13332       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13333
13334       /* Detect integral division by zero */
13335       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13336           && TREE_CODE (prom_type) == INTEGER_TYPE
13337           && (op2 == integer_zero_node || op2 == long_zero_node ||
13338               (TREE_CODE (op2) == INTEGER_CST &&
13339                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13340         {
13341           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13342           TREE_CONSTANT (node) = 0;
13343         }
13344
13345       /* Change the division operator if necessary */
13346       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13347         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13348
13349       /* Before divisions as is disappear, try to simplify and bail if
13350          applicable, otherwise we won't perform even simple
13351          simplifications like (1-1)/3. We can't do that with floating
13352          point number, folds can't handle them at this stage. */
13353       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13354           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13355         {
13356           TREE_TYPE (node) = prom_type;
13357           node = fold (node);
13358           if (TREE_CODE (node) != code)
13359             return node;
13360         }
13361
13362       if (TREE_CODE (prom_type) == INTEGER_TYPE
13363           && flag_use_divide_subroutine
13364           && ! flag_emit_class_files
13365           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13366         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13367
13368       /* This one is more complicated. FLOATs are processed by a
13369          function call to soft_fmod. Duplicate the value of the
13370          COMPOUND_ASSIGN_P flag. */
13371       if (code == TRUNC_MOD_EXPR)
13372         {
13373           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13374           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13375           TREE_SIDE_EFFECTS (mod)
13376             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13377           return mod;
13378         }
13379       break;
13380
13381     /* 15.17 Additive Operators */
13382     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13383
13384       /* Operation is valid if either one argument is a string
13385          constant, a String object or a StringBuffer crafted for the
13386          purpose of the a previous usage of the String concatenation
13387          operator */
13388
13389       if (TREE_CODE (op1) == STRING_CST
13390           || TREE_CODE (op2) == STRING_CST
13391           || JSTRING_TYPE_P (op1_type)
13392           || JSTRING_TYPE_P (op2_type)
13393           || IS_CRAFTED_STRING_BUFFER_P (op1)
13394           || IS_CRAFTED_STRING_BUFFER_P (op2))
13395         return build_string_concatenation (op1, op2);
13396
13397     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13398                                    Numeric Types */
13399       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13400         {
13401           if (!JNUMERIC_TYPE_P (op1_type))
13402             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13403           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13404             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13405           TREE_TYPE (node) = error_mark_node;
13406           error_found = 1;
13407           break;
13408         }
13409       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13410       break;
13411
13412     /* 15.18 Shift Operators */
13413     case LSHIFT_EXPR:
13414     case RSHIFT_EXPR:
13415     case URSHIFT_EXPR:
13416       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13417         {
13418           if (!JINTEGRAL_TYPE_P (op1_type))
13419             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13420           else
13421             {
13422               if (JNUMERIC_TYPE_P (op2_type))
13423                 parse_error_context (wfl_operator,
13424                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13425                                      operator_string (node),
13426                                      lang_printable_name (op2_type, 0));
13427               else
13428                 parse_error_context (wfl_operator,
13429                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13430                                      operator_string (node),
13431                                      lang_printable_name (op2_type, 0));
13432             }
13433           TREE_TYPE (node) = error_mark_node;
13434           error_found = 1;
13435           break;
13436         }
13437
13438       /* Unary numeric promotion (5.6.1) is performed on each operand
13439          separately */
13440       op1 = do_unary_numeric_promotion (op1);
13441       op2 = do_unary_numeric_promotion (op2);
13442
13443       /* If the right hand side is of type `long', first cast it to
13444          `int'.  */
13445       if (TREE_TYPE (op2) == long_type_node)
13446         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13447
13448       /* The type of the shift expression is the type of the promoted
13449          type of the left-hand operand */
13450       prom_type = TREE_TYPE (op1);
13451
13452       /* Shift int only up to 0x1f and long up to 0x3f */
13453       if (prom_type == int_type_node)
13454         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13455                            build_int_2 (0x1f, 0)));
13456       else
13457         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13458                            build_int_2 (0x3f, 0)));
13459
13460       /* The >>> operator is a >> operating on unsigned quantities */
13461       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13462         {
13463           tree to_return;
13464           tree utype = java_unsigned_type (prom_type);
13465           op1 = convert (utype, op1);
13466           TREE_SET_CODE (node, RSHIFT_EXPR);
13467           TREE_OPERAND (node, 0) = op1;
13468           TREE_OPERAND (node, 1) = op2;
13469           TREE_TYPE (node) = utype;
13470           to_return = convert (prom_type, node);
13471           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13472           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13473           TREE_SIDE_EFFECTS (to_return)
13474             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13475           return to_return;
13476         }
13477       break;
13478
13479       /* 15.19.1 Type Comparison Operator instanceof */
13480     case INSTANCEOF_EXPR:
13481
13482       TREE_TYPE (node) = boolean_type_node;
13483
13484       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13485       if ((cn = patch_string (op1)))
13486         {
13487           op1 = cn;
13488           op1_type = TREE_TYPE (op1);
13489         }
13490       if (op1_type == NULL_TREE)
13491         abort ();
13492
13493       if (!(op2_type = resolve_type_during_patch (op2)))
13494         return error_mark_node;
13495
13496       /* The first operand must be a reference type or the null type */
13497       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13498         error_found = 1;        /* Error reported further below */
13499
13500       /* The second operand must be a reference type */
13501       if (!JREFERENCE_TYPE_P (op2_type))
13502         {
13503           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13504           parse_error_context
13505             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13506              lang_printable_name (op2_type, 0));
13507           error_found = 1;
13508         }
13509
13510       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13511         {
13512           /* If the first operand is null, the result is always false */
13513           if (op1 == null_pointer_node)
13514             return boolean_false_node;
13515           else if (flag_emit_class_files)
13516             {
13517               TREE_OPERAND (node, 1) = op2_type;
13518               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13519               return node;
13520             }
13521           /* Otherwise we have to invoke instance of to figure it out */
13522           else
13523             return build_instanceof (op1, op2_type);
13524         }
13525       /* There is no way the expression operand can be an instance of
13526          the type operand. This is a compile time error. */
13527       else
13528         {
13529           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13530           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13531           parse_error_context
13532             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13533              t1, lang_printable_name (op2_type, 0));
13534           free (t1);
13535           error_found = 1;
13536         }
13537
13538       break;
13539
13540       /* 15.21 Bitwise and Logical Operators */
13541     case BIT_AND_EXPR:
13542     case BIT_XOR_EXPR:
13543     case BIT_IOR_EXPR:
13544       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13545         /* Binary numeric promotion is performed on both operand and the
13546            expression retain that type */
13547         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13548
13549       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13550                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13551         /* The type of the bitwise operator expression is BOOLEAN */
13552         prom_type = boolean_type_node;
13553       else
13554         {
13555           if (!JINTEGRAL_TYPE_P (op1_type))
13556             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13557           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13558             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13559           TREE_TYPE (node) = error_mark_node;
13560           error_found = 1;
13561           /* Insert a break here if adding thing before the switch's
13562              break for this case */
13563         }
13564       break;
13565
13566       /* 15.22 Conditional-And Operator */
13567     case TRUTH_ANDIF_EXPR:
13568       /* 15.23 Conditional-Or Operator */
13569     case TRUTH_ORIF_EXPR:
13570       /* Operands must be of BOOLEAN type */
13571       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13572           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13573         {
13574           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13575             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13576           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13577             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13578           TREE_TYPE (node) = boolean_type_node;
13579           error_found = 1;
13580           break;
13581         }
13582       else if (integer_zerop (op1))
13583         {
13584           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13585         }
13586       else if (integer_onep (op1))
13587         {
13588           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13589         }
13590       /* The type of the conditional operators is BOOLEAN */
13591       prom_type = boolean_type_node;
13592       break;
13593
13594       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13595     case LT_EXPR:
13596     case GT_EXPR:
13597     case LE_EXPR:
13598     case GE_EXPR:
13599       /* The type of each of the operands must be a primitive numeric
13600          type */
13601       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13602         {
13603           if (!JNUMERIC_TYPE_P (op1_type))
13604             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13605           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13606             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13607           TREE_TYPE (node) = boolean_type_node;
13608           error_found = 1;
13609           break;
13610         }
13611       /* Binary numeric promotion is performed on the operands */
13612       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13613       /* The type of the relation expression is always BOOLEAN */
13614       prom_type = boolean_type_node;
13615       break;
13616
13617       /* 15.20 Equality Operator */
13618     case EQ_EXPR:
13619     case NE_EXPR:
13620       /* It's time for us to patch the strings. */
13621       if ((cn = patch_string (op1)))
13622        {
13623          op1 = cn;
13624          op1_type = TREE_TYPE (op1);
13625        }
13626       if ((cn = patch_string (op2)))
13627        {
13628          op2 = cn;
13629          op2_type = TREE_TYPE (op2);
13630        }
13631
13632       /* 15.20.1 Numerical Equality Operators == and != */
13633       /* Binary numeric promotion is performed on the operands */
13634       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13635         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13636
13637       /* 15.20.2 Boolean Equality Operators == and != */
13638       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13639           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13640         ;                       /* Nothing to do here */
13641
13642       /* 15.20.3 Reference Equality Operators == and != */
13643       /* Types have to be either references or the null type. If
13644          they're references, it must be possible to convert either
13645          type to the other by casting conversion. */
13646       else if (op1 == null_pointer_node || op2 == null_pointer_node
13647                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13648                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13649                        || valid_ref_assignconv_cast_p (op2_type,
13650                                                        op1_type, 1))))
13651         ;                       /* Nothing to do here */
13652
13653       /* Else we have an error figure what can't be converted into
13654          what and report the error */
13655       else
13656         {
13657           char *t1;
13658           t1 = xstrdup (lang_printable_name (op1_type, 0));
13659           parse_error_context
13660             (wfl_operator,
13661              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13662              operator_string (node), t1,
13663              lang_printable_name (op2_type, 0));
13664           free (t1);
13665           TREE_TYPE (node) = boolean_type_node;
13666           error_found = 1;
13667           break;
13668         }
13669       prom_type = boolean_type_node;
13670       break;
13671     default:
13672       abort ();
13673     }
13674
13675   if (error_found)
13676     return error_mark_node;
13677
13678   TREE_OPERAND (node, 0) = op1;
13679   TREE_OPERAND (node, 1) = op2;
13680   TREE_TYPE (node) = prom_type;
13681   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13682
13683   if (flag_emit_xref)
13684     return node;
13685
13686   /* fold does not respect side-effect order as required for Java but not C.
13687    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13688    * bytecode.
13689    */
13690   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13691       : ! TREE_SIDE_EFFECTS (node))
13692     node = fold (node);
13693   return node;
13694 }
13695
13696 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13697    zero value, the value of CSTE comes after the valude of STRING */
13698
13699 static tree
13700 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13701 {
13702   const char *old = TREE_STRING_POINTER (cste);
13703   int old_len = TREE_STRING_LENGTH (cste);
13704   int len = old_len + string_len;
13705   char *new = alloca (len+1);
13706
13707   if (after)
13708     {
13709       memcpy (new, string, string_len);
13710       memcpy (&new [string_len], old, old_len);
13711     }
13712   else
13713     {
13714       memcpy (new, old, old_len);
13715       memcpy (&new [old_len], string, string_len);
13716     }
13717   new [len] = '\0';
13718   return build_string (len, new);
13719 }
13720
13721 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13722    new STRING_CST on success, NULL_TREE on failure.  */
13723
13724 static tree
13725 merge_string_cste (tree op1, tree op2, int after)
13726 {
13727   /* Handle two string constants right away.  */
13728   if (TREE_CODE (op2) == STRING_CST)
13729     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13730                                  TREE_STRING_LENGTH (op2), after);
13731
13732   /* Reasonable integer constant can be treated right away.  */
13733   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13734     {
13735       static const char *const boolean_true = "true";
13736       static const char *const boolean_false = "false";
13737       static const char *const null_pointer = "null";
13738       char ch[4];
13739       const char *string;
13740
13741       if (op2 == boolean_true_node)
13742         string = boolean_true;
13743       else if (op2 == boolean_false_node)
13744         string = boolean_false;
13745       else if (op2 == null_pointer_node
13746                || (integer_zerop (op2)
13747                    && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
13748         /* FIXME: null is not a compile-time constant, so it is only safe to
13749            merge if the overall expression is non-constant. However, this
13750            code always merges without checking the overall expression.  */
13751         string = null_pointer;
13752       else if (TREE_TYPE (op2) == char_type_node)
13753         {
13754           /* Convert the character into UTF-8.  */
13755           unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13756           unsigned char *p = (unsigned char *) ch;
13757           if (0x01 <= c && c <= 0x7f)
13758             *p++ = (unsigned char) c;
13759           else if (c < 0x7ff)
13760             {
13761               *p++ = (unsigned char) (c >> 6 | 0xc0);
13762               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13763             }
13764           else
13765             {
13766               *p++ = (unsigned char) (c >> 12 | 0xe0);
13767               *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13768               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13769             }
13770           *p = '\0';
13771
13772           string = ch;
13773         }
13774       else
13775         string = string_convert_int_cst (op2);
13776
13777       return do_merge_string_cste (op1, string, strlen (string), after);
13778     }
13779   return NULL_TREE;
13780 }
13781
13782 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13783    has to be a STRING_CST and the other part must be a STRING_CST or a
13784    INTEGRAL constant. Return a new STRING_CST if the operation
13785    succeed, NULL_TREE otherwise.
13786
13787    If the case we want to optimize for space, we might want to return
13788    NULL_TREE for each invocation of this routine. FIXME */
13789
13790 static tree
13791 string_constant_concatenation (tree op1, tree op2)
13792 {
13793   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13794     {
13795       tree string, rest;
13796       int invert;
13797
13798       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13799       rest   = (string == op1 ? op2 : op1);
13800       invert = (string == op1 ? 0 : 1 );
13801
13802       /* Walk REST, only if it looks reasonable */
13803       if (TREE_CODE (rest) != STRING_CST
13804           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13805           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13806           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13807         {
13808           rest = java_complete_tree (rest);
13809           if (rest == error_mark_node)
13810             return error_mark_node;
13811           rest = fold (rest);
13812         }
13813       return merge_string_cste (string, rest, invert);
13814     }
13815   return NULL_TREE;
13816 }
13817
13818 /* Implement the `+' operator. Does static optimization if possible,
13819    otherwise create (if necessary) and append elements to a
13820    StringBuffer. The StringBuffer will be carried around until it is
13821    used for a function call or an assignment. Then toString() will be
13822    called on it to turn it into a String object. */
13823
13824 static tree
13825 build_string_concatenation (tree op1, tree op2)
13826 {
13827   tree result;
13828   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13829
13830   if (flag_emit_xref)
13831     return build (PLUS_EXPR, string_type_node, op1, op2);
13832
13833   /* Try to do some static optimization */
13834   if ((result = string_constant_concatenation (op1, op2)))
13835     return result;
13836
13837   /* Discard empty strings on either side of the expression */
13838   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13839     {
13840       op1 = op2;
13841       op2 = NULL_TREE;
13842     }
13843   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13844     op2 = NULL_TREE;
13845
13846   /* If operands are string constant, turn then into object references */
13847   if (TREE_CODE (op1) == STRING_CST)
13848     op1 = patch_string_cst (op1);
13849   if (op2 && TREE_CODE (op2) == STRING_CST)
13850     op2 = patch_string_cst (op2);
13851
13852   /* If either one of the constant is null and the other non null
13853      operand is a String constant, return it. */
13854   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13855     return op1;
13856
13857   /* If OP1 isn't already a StringBuffer, create and
13858      initialize a new one */
13859   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13860     {
13861       /* Two solutions here:
13862          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13863          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13864       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13865         op1 = BUILD_STRING_BUFFER (op1);
13866       else
13867         {
13868           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13869           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13870         }
13871     }
13872
13873   if (op2)
13874     {
13875       /* OP1 is no longer the last node holding a crafted StringBuffer */
13876       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13877       /* Create a node for `{new...,xxx}.append (op2)' */
13878       if (op2)
13879         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13880     }
13881
13882   /* Mark the last node holding a crafted StringBuffer */
13883   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13884
13885   TREE_SIDE_EFFECTS (op1) = side_effects;
13886   return op1;
13887 }
13888
13889 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13890    StringBuffer. If no string were found to be patched, return
13891    NULL. */
13892
13893 static tree
13894 patch_string (tree node)
13895 {
13896   if (node == error_mark_node)
13897     return error_mark_node;
13898   if (TREE_CODE (node) == STRING_CST)
13899     return patch_string_cst (node);
13900   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13901     {
13902       int saved = ctxp->explicit_constructor_p;
13903       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13904       tree ret;
13905       /* Temporary disable forbid the use of `this'. */
13906       ctxp->explicit_constructor_p = 0;
13907       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13908       /* String concatenation arguments must be evaluated in order too. */
13909       ret = force_evaluation_order (ret);
13910       /* Restore it at its previous value */
13911       ctxp->explicit_constructor_p = saved;
13912       return ret;
13913     }
13914   return NULL_TREE;
13915 }
13916
13917 /* Build the internal representation of a string constant.  */
13918
13919 static tree
13920 patch_string_cst (tree node)
13921 {
13922   int location;
13923   if (! flag_emit_class_files)
13924     {
13925       node = get_identifier (TREE_STRING_POINTER (node));
13926       location = alloc_name_constant (CONSTANT_String, node);
13927       node = build_ref_from_constant_pool (location);
13928     }
13929   TREE_TYPE (node) = string_ptr_type_node;
13930   TREE_CONSTANT (node) = 1;
13931   return node;
13932 }
13933
13934 /* Build an incomplete unary operator expression. */
13935
13936 static tree
13937 build_unaryop (int op_token, int op_location, tree op1)
13938 {
13939   enum tree_code op;
13940   tree unaryop;
13941   switch (op_token)
13942     {
13943     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13944     case MINUS_TK: op = NEGATE_EXPR; break;
13945     case NEG_TK: op = TRUTH_NOT_EXPR; break;
13946     case NOT_TK: op = BIT_NOT_EXPR; break;
13947     default: abort ();
13948     }
13949
13950   unaryop = build1 (op, NULL_TREE, op1);
13951   TREE_SIDE_EFFECTS (unaryop) = 1;
13952   /* Store the location of the operator, for better error report. The
13953      string of the operator will be rebuild based on the OP value. */
13954   EXPR_WFL_LINECOL (unaryop) = op_location;
13955   return unaryop;
13956 }
13957
13958 /* Special case for the ++/-- operators, since they require an extra
13959    argument to build, which is set to NULL and patched
13960    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
13961
13962 static tree
13963 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
13964 {
13965   static const enum tree_code lookup [2][2] =
13966     {
13967       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
13968       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
13969     };
13970   tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
13971                      NULL_TREE, op1, NULL_TREE);
13972   TREE_SIDE_EFFECTS (node) = 1;
13973   /* Store the location of the operator, for better error report. The
13974      string of the operator will be rebuild based on the OP value. */
13975   EXPR_WFL_LINECOL (node) = op_location;
13976   return node;
13977 }
13978
13979 /* Build an incomplete cast operator, based on the use of the
13980    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13981    set. java_complete_tree is trained to walk a CONVERT_EXPR even
13982    though its type is already set.  */
13983
13984 static tree
13985 build_cast (int location, tree type, tree exp)
13986 {
13987   tree node = build1 (CONVERT_EXPR, type, exp);
13988   EXPR_WFL_LINECOL (node) = location;
13989   return node;
13990 }
13991
13992 /* Build an incomplete class reference operator.  */
13993 static tree
13994 build_incomplete_class_ref (int location, tree class_name)
13995 {
13996   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13997   tree class_decl = GET_CPC ();
13998   tree this_class = TREE_TYPE (class_decl);
13999
14000   /* Generate the synthetic static method `class$'.  (Previously we
14001      deferred this, causing different method tables to be emitted
14002      for native code and bytecode.)  */
14003   if (!TYPE_DOT_CLASS (this_class)
14004       && !JPRIMITIVE_TYPE_P (class_name)
14005       && !(TREE_CODE (class_name) == VOID_TYPE))
14006     {
14007       tree cpc_list = GET_CPC_LIST();
14008       tree cpc = cpc_list;
14009       tree target_class;
14010
14011       /* For inner classes, add a 'class$' method to their outermost
14012          context, creating it if necessary.  */
14013
14014       while (GET_NEXT_ENCLOSING_CPC(cpc))
14015         cpc = GET_NEXT_ENCLOSING_CPC(cpc);
14016       class_decl = TREE_VALUE (cpc);
14017
14018       target_class = TREE_TYPE (class_decl);
14019
14020       if (CLASS_INTERFACE (TYPE_NAME (target_class)))
14021         {
14022           /* For interfaces, adding a static 'class$' method directly
14023              is illegal.  So create an inner class to contain the new
14024              method.  Empirically this matches the behavior of javac.  */
14025           tree t, inner;
14026           /* We want the generated inner class inside the outermost class. */
14027           GET_CPC_LIST() = cpc;
14028           t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
14029           inner = create_anonymous_class (0, t);
14030           target_class = TREE_TYPE (inner);
14031           end_class_declaration (1);
14032           GET_CPC_LIST() = cpc_list;
14033         }
14034
14035       if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
14036         build_dot_class_method (target_class);
14037
14038       if (this_class != target_class)
14039         TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
14040     }
14041
14042   EXPR_WFL_LINECOL (node) = location;
14043   return node;
14044 }
14045
14046 /* Complete an incomplete class reference operator.  */
14047 static tree
14048 patch_incomplete_class_ref (tree node)
14049 {
14050   tree type = TREE_OPERAND (node, 0);
14051   tree ref_type;
14052
14053   if (!(ref_type = resolve_type_during_patch (type)))
14054     return error_mark_node;
14055
14056   /* If we're not emitting class files and we know ref_type is a
14057      compiled class, build a direct reference.  */
14058   if ((! flag_emit_class_files && is_compiled_class (ref_type))
14059       || JPRIMITIVE_TYPE_P (ref_type)
14060       || TREE_CODE (ref_type) == VOID_TYPE)
14061     {
14062       tree dot = build_class_ref (ref_type);
14063       /* A class referenced by `foo.class' is initialized.  */
14064       if (!flag_emit_class_files)
14065        dot = build_class_init (ref_type, dot);
14066       return java_complete_tree (dot);
14067     }
14068
14069   /* If we're emitting class files and we have to deal with non
14070      primitive types, we invoke the synthetic static method `class$'.  */
14071   ref_type = build_dot_class_method_invocation (current_class, ref_type);
14072   return java_complete_tree (ref_type);
14073 }
14074
14075 /* 15.14 Unary operators. We return error_mark_node in case of error,
14076    but preserve the type of NODE if the type is fixed.  */
14077
14078 static tree
14079 patch_unaryop (tree node, tree wfl_op)
14080 {
14081   tree op = TREE_OPERAND (node, 0);
14082   tree op_type = TREE_TYPE (op);
14083   tree prom_type = NULL_TREE, value, decl;
14084   int outer_field_flag = 0;
14085   int code = TREE_CODE (node);
14086   int error_found = 0;
14087
14088   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14089
14090   switch (code)
14091     {
14092       /* 15.13.2 Postfix Increment Operator ++ */
14093     case POSTINCREMENT_EXPR:
14094       /* 15.13.3 Postfix Increment Operator -- */
14095     case POSTDECREMENT_EXPR:
14096       /* 15.14.1 Prefix Increment Operator ++ */
14097     case PREINCREMENT_EXPR:
14098       /* 15.14.2 Prefix Decrement Operator -- */
14099     case PREDECREMENT_EXPR:
14100       op = decl = strip_out_static_field_access_decl (op);
14101       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14102       /* We might be trying to change an outer field accessed using
14103          access method. */
14104       if (outer_field_flag)
14105         {
14106           /* Retrieve the decl of the field we're trying to access. We
14107              do that by first retrieving the function we would call to
14108              access the field. It has been already verified that this
14109              field isn't final */
14110           if (flag_emit_class_files)
14111             decl = TREE_OPERAND (op, 0);
14112           else
14113             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14114           decl = DECL_FUNCTION_ACCESS_DECL (decl);
14115         }
14116       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14117       else if (!JDECL_P (decl)
14118           && TREE_CODE (decl) != COMPONENT_REF
14119           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14120           && TREE_CODE (decl) != INDIRECT_REF
14121           && !(TREE_CODE (decl) == COMPOUND_EXPR
14122                && TREE_OPERAND (decl, 1)
14123                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14124         {
14125           TREE_TYPE (node) = error_mark_node;
14126           error_found = 1;
14127         }
14128
14129       /* From now on, we know that op if a variable and that it has a
14130          valid wfl. We use wfl_op to locate errors related to the
14131          ++/-- operand. */
14132       if (!JNUMERIC_TYPE_P (op_type))
14133         {
14134           parse_error_context
14135             (wfl_op, "Invalid argument type `%s' to `%s'",
14136              lang_printable_name (op_type, 0), operator_string (node));
14137           TREE_TYPE (node) = error_mark_node;
14138           error_found = 1;
14139         }
14140       else
14141         {
14142           /* Before the addition, binary numeric promotion is performed on
14143              both operands, if really necessary */
14144           if (JINTEGRAL_TYPE_P (op_type))
14145             {
14146               value = build_int_2 (1, 0);
14147               TREE_TYPE (value) = TREE_TYPE (node) = op_type;
14148             }
14149           else
14150             {
14151               value = build_int_2 (1, 0);
14152               TREE_TYPE (node) =
14153                 binary_numeric_promotion (op_type,
14154                                           TREE_TYPE (value), &op, &value);
14155             }
14156
14157           /* We remember we might be accessing an outer field */
14158           if (outer_field_flag)
14159             {
14160               /* We re-generate an access to the field */
14161               value = build (PLUS_EXPR, TREE_TYPE (op),
14162                              build_outer_field_access (wfl_op, decl), value);
14163
14164               /* And we patch the original access$() into a write
14165                  with plus_op as a rhs */
14166               return outer_field_access_fix (node, op, value);
14167             }
14168
14169           /* And write back into the node. */
14170           TREE_OPERAND (node, 0) = op;
14171           TREE_OPERAND (node, 1) = value;
14172           /* Convert the overall back into its original type, if
14173              necessary, and return */
14174           if (JINTEGRAL_TYPE_P (op_type))
14175             return fold (node);
14176           else
14177             return fold (convert (op_type, node));
14178         }
14179       break;
14180
14181       /* 15.14.3 Unary Plus Operator + */
14182     case UNARY_PLUS_EXPR:
14183       /* 15.14.4 Unary Minus Operator - */
14184     case NEGATE_EXPR:
14185       if (!JNUMERIC_TYPE_P (op_type))
14186         {
14187           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14188           TREE_TYPE (node) = error_mark_node;
14189           error_found = 1;
14190         }
14191       /* Unary numeric promotion is performed on operand */
14192       else
14193         {
14194           op = do_unary_numeric_promotion (op);
14195           prom_type = TREE_TYPE (op);
14196           if (code == UNARY_PLUS_EXPR)
14197             return fold (op);
14198         }
14199       break;
14200
14201       /* 15.14.5 Bitwise Complement Operator ~ */
14202     case BIT_NOT_EXPR:
14203       if (!JINTEGRAL_TYPE_P (op_type))
14204         {
14205           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14206           TREE_TYPE (node) = error_mark_node;
14207           error_found = 1;
14208         }
14209       else
14210         {
14211           op = do_unary_numeric_promotion (op);
14212           prom_type = TREE_TYPE (op);
14213         }
14214       break;
14215
14216       /* 15.14.6 Logical Complement Operator ! */
14217     case TRUTH_NOT_EXPR:
14218       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14219         {
14220           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14221           /* But the type is known. We will report an error if further
14222              attempt of a assignment is made with this rhs */
14223           TREE_TYPE (node) = boolean_type_node;
14224           error_found = 1;
14225         }
14226       else
14227         prom_type = boolean_type_node;
14228       break;
14229
14230       /* 15.15 Cast Expression */
14231     case CONVERT_EXPR:
14232       value = patch_cast (node, wfl_operator);
14233       if (value == error_mark_node)
14234         {
14235           /* If this cast is part of an assignment, we tell the code
14236              that deals with it not to complain about a mismatch,
14237              because things have been cast, anyways */
14238           TREE_TYPE (node) = error_mark_node;
14239           error_found = 1;
14240         }
14241       else
14242         {
14243           value = fold (value);
14244           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14245           return value;
14246         }
14247       break;
14248     }
14249
14250   if (error_found)
14251     return error_mark_node;
14252
14253   /* There are cases where node has been replaced by something else
14254      and we don't end up returning here: UNARY_PLUS_EXPR,
14255      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14256   TREE_OPERAND (node, 0) = fold (op);
14257   TREE_TYPE (node) = prom_type;
14258   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14259   return fold (node);
14260 }
14261
14262 /* Generic type resolution that sometimes takes place during node
14263    patching. Returned the resolved type or generate an error
14264    message. Return the resolved type or NULL_TREE.  */
14265
14266 static tree
14267 resolve_type_during_patch (tree type)
14268 {
14269   if (unresolved_type_p (type, NULL))
14270     {
14271       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14272       if (!type_decl)
14273         {
14274           parse_error_context (type,
14275                                "Class `%s' not found in type declaration",
14276                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14277           return NULL_TREE;
14278         }
14279
14280       check_deprecation (type, type_decl);
14281
14282       return TREE_TYPE (type_decl);
14283     }
14284   return type;
14285 }
14286
14287 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14288    found. Otherwise NODE or something meant to replace it is returned.  */
14289
14290 static tree
14291 patch_cast (tree node, tree wfl_op)
14292 {
14293   tree op = TREE_OPERAND (node, 0);
14294   tree cast_type = TREE_TYPE (node);
14295   tree patched, op_type;
14296   char *t1;
14297
14298   /* Some string patching might be necessary at this stage */
14299   if ((patched = patch_string (op)))
14300     TREE_OPERAND (node, 0) = op = patched;
14301   op_type = TREE_TYPE (op);
14302
14303   /* First resolve OP_TYPE if unresolved */
14304   if (!(cast_type = resolve_type_during_patch (cast_type)))
14305     return error_mark_node;
14306
14307   /* Check on cast that are proven correct at compile time */
14308   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14309     {
14310       /* Same type */
14311       if (cast_type == op_type)
14312         return node;
14313
14314       /* A narrowing conversion from a floating-point number to an
14315          integral type requires special handling (5.1.3).  */
14316       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14317         if (cast_type != long_type_node)
14318           op = convert (integer_type_node, op);
14319
14320       /* Try widening/narrowing conversion.  Potentially, things need
14321          to be worked out in gcc so we implement the extreme cases
14322          correctly.  fold_convert() needs to be fixed.  */
14323       return convert (cast_type, op);
14324     }
14325
14326   /* It's also valid to cast a boolean into a boolean */
14327   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14328     return node;
14329
14330   /* null can be casted to references */
14331   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14332     return build_null_of_type (cast_type);
14333
14334   /* The remaining legal casts involve conversion between reference
14335      types. Check for their compile time correctness. */
14336   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14337       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14338     {
14339       TREE_TYPE (node) = promote_type (cast_type);
14340       /* Now, the case can be determined correct at compile time if
14341          OP_TYPE can be converted into CAST_TYPE by assignment
14342          conversion (5.2) */
14343
14344       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14345         {
14346           TREE_SET_CODE (node, NOP_EXPR);
14347           return node;
14348         }
14349
14350       if (flag_emit_class_files)
14351         {
14352           TREE_SET_CODE (node, CONVERT_EXPR);
14353           return node;
14354         }
14355
14356       /* The cast requires a run-time check */
14357       return build (CALL_EXPR, promote_type (cast_type),
14358                     build_address_of (soft_checkcast_node),
14359                     tree_cons (NULL_TREE, build_class_ref (cast_type),
14360                                build_tree_list (NULL_TREE, op)),
14361                     NULL_TREE);
14362     }
14363
14364   /* Any other casts are proven incorrect at compile time */
14365   t1 = xstrdup (lang_printable_name (op_type, 0));
14366   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14367                        t1, lang_printable_name (cast_type, 0));
14368   free (t1);
14369   return error_mark_node;
14370 }
14371
14372 /* Build a null constant and give it the type TYPE.  */
14373
14374 static tree
14375 build_null_of_type (tree type)
14376 {
14377   tree node = build_int_2 (0, 0);
14378   TREE_TYPE (node) = promote_type (type);
14379   return node;
14380 }
14381
14382 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14383    a list of indices. */
14384 static tree
14385 build_array_ref (int location, tree array, tree index)
14386 {
14387   tree node = build (ARRAY_REF, NULL_TREE, array, index);
14388   EXPR_WFL_LINECOL (node) = location;
14389   return node;
14390 }
14391
14392 /* 15.12 Array Access Expression */
14393
14394 static tree
14395 patch_array_ref (tree node)
14396 {
14397   tree array = TREE_OPERAND (node, 0);
14398   tree array_type  = TREE_TYPE (array);
14399   tree index = TREE_OPERAND (node, 1);
14400   tree index_type = TREE_TYPE (index);
14401   int error_found = 0;
14402
14403   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14404
14405   if (TREE_CODE (array_type) == POINTER_TYPE)
14406     array_type = TREE_TYPE (array_type);
14407
14408   /* The array reference must be an array */
14409   if (!TYPE_ARRAY_P (array_type))
14410     {
14411       parse_error_context
14412         (wfl_operator,
14413          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14414          lang_printable_name (array_type, 0));
14415       TREE_TYPE (node) = error_mark_node;
14416       error_found = 1;
14417     }
14418
14419   /* The array index undergoes unary numeric promotion. The promoted
14420      type must be int */
14421   index = do_unary_numeric_promotion (index);
14422   if (TREE_TYPE (index) != int_type_node)
14423     {
14424       if (valid_cast_to_p (index_type, int_type_node))
14425         parse_error_context (wfl_operator,
14426    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14427                              lang_printable_name (index_type, 0));
14428       else
14429         parse_error_context (wfl_operator,
14430           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14431                              lang_printable_name (index_type, 0));
14432       TREE_TYPE (node) = error_mark_node;
14433       error_found = 1;
14434     }
14435
14436   if (error_found)
14437     return error_mark_node;
14438
14439   array_type = TYPE_ARRAY_ELEMENT (array_type);
14440
14441   if (flag_emit_class_files || flag_emit_xref)
14442     {
14443       TREE_OPERAND (node, 0) = array;
14444       TREE_OPERAND (node, 1) = index;
14445     }
14446   else
14447     node = build_java_arrayaccess (array, array_type, index);
14448   TREE_TYPE (node) = array_type;
14449   return node;
14450 }
14451
14452 /* 15.9 Array Creation Expressions */
14453
14454 static tree
14455 build_newarray_node (tree type, tree dims, int extra_dims)
14456 {
14457   tree node =
14458     build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
14459            build_int_2 (extra_dims, 0));
14460   return node;
14461 }
14462
14463 static tree
14464 patch_newarray (tree node)
14465 {
14466   tree type = TREE_OPERAND (node, 0);
14467   tree dims = TREE_OPERAND (node, 1);
14468   tree cdim, array_type;
14469   int error_found = 0;
14470   int ndims = 0;
14471   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14472
14473   /* Dimension types are verified. It's better for the types to be
14474      verified in order. */
14475   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14476     {
14477       int dim_error = 0;
14478       tree dim = TREE_VALUE (cdim);
14479
14480       /* Dim might have been saved during its evaluation */
14481       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14482
14483       /* The type of each specified dimension must be an integral type. */
14484       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14485         dim_error = 1;
14486
14487       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14488          promoted type must be int. */
14489       else
14490         {
14491           dim = do_unary_numeric_promotion (dim);
14492           if (TREE_TYPE (dim) != int_type_node)
14493             dim_error = 1;
14494         }
14495
14496       /* Report errors on types here */
14497       if (dim_error)
14498         {
14499           parse_error_context
14500             (TREE_PURPOSE (cdim),
14501              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14502              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14503               "Explicit cast needed to" : "Can't"),
14504              lang_printable_name (TREE_TYPE (dim), 0));
14505           error_found = 1;
14506         }
14507
14508       TREE_PURPOSE (cdim) = NULL_TREE;
14509     }
14510
14511   /* Resolve array base type if unresolved */
14512   if (!(type = resolve_type_during_patch (type)))
14513     error_found = 1;
14514
14515   if (error_found)
14516     {
14517       /* We don't want further evaluation of this bogus array creation
14518          operation */
14519       TREE_TYPE (node) = error_mark_node;
14520       return error_mark_node;
14521     }
14522
14523   /* Set array_type to the actual (promoted) array type of the result. */
14524   if (TREE_CODE (type) == RECORD_TYPE)
14525     type = build_pointer_type (type);
14526   while (--xdims >= 0)
14527     {
14528       type = promote_type (build_java_array_type (type, -1));
14529     }
14530   dims = nreverse (dims);
14531   array_type = type;
14532   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14533     {
14534       type = array_type;
14535       array_type
14536         = build_java_array_type (type,
14537                                  TREE_CODE (cdim) == INTEGER_CST
14538                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14539                                  : -1);
14540       array_type = promote_type (array_type);
14541     }
14542   dims = nreverse (dims);
14543
14544   /* The node is transformed into a function call. Things are done
14545      differently according to the number of dimensions. If the number
14546      of dimension is equal to 1, then the nature of the base type
14547      (primitive or not) matters. */
14548   if (ndims == 1)
14549     return build_new_array (type, TREE_VALUE (dims));
14550
14551   /* Can't reuse what's already written in expr.c because it uses the
14552      JVM stack representation. Provide a build_multianewarray. FIXME */
14553   return build (CALL_EXPR, array_type,
14554                 build_address_of (soft_multianewarray_node),
14555                 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
14556                            tree_cons (NULL_TREE,
14557                                       build_int_2 (ndims, 0), dims )),
14558                 NULL_TREE);
14559 }
14560
14561 /* 10.6 Array initializer.  */
14562
14563 /* Build a wfl for array element that don't have one, so we can
14564    pin-point errors.  */
14565
14566 static tree
14567 maybe_build_array_element_wfl (tree node)
14568 {
14569   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14570     return build_expr_wfl (NULL_TREE, ctxp->filename,
14571                            ctxp->elc.line, ctxp->elc.prev_col);
14572   else
14573     return NULL_TREE;
14574 }
14575
14576 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14577    identification of initialized arrays easier to detect during walk
14578    and expansion.  */
14579
14580 static tree
14581 build_new_array_init (int location, tree values)
14582 {
14583   tree constructor = build_constructor (NULL_TREE, values);
14584   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14585   EXPR_WFL_LINECOL (to_return) = location;
14586   return to_return;
14587 }
14588
14589 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14590    occurred.  Otherwise return NODE after having set its type
14591    appropriately.  */
14592
14593 static tree
14594 patch_new_array_init (tree type, tree node)
14595 {
14596   int error_seen = 0;
14597   tree current, element_type;
14598   HOST_WIDE_INT length;
14599   int all_constant = 1;
14600   tree init = TREE_OPERAND (node, 0);
14601
14602   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14603     {
14604       parse_error_context (node,
14605                            "Invalid array initializer for non-array type `%s'",
14606                            lang_printable_name (type, 1));
14607       return error_mark_node;
14608     }
14609   type = TREE_TYPE (type);
14610   element_type = TYPE_ARRAY_ELEMENT (type);
14611
14612   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14613
14614   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14615        current;  length++, current = TREE_CHAIN (current))
14616     {
14617       tree elt = TREE_VALUE (current);
14618       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14619         {
14620           error_seen |= array_constructor_check_entry (element_type, current);
14621           elt = TREE_VALUE (current);
14622           /* When compiling to native code, STRING_CST is converted to
14623              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14624           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14625             all_constant = 0;
14626         }
14627       else
14628         {
14629           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14630           TREE_PURPOSE (current) = NULL_TREE;
14631           all_constant = 0;
14632         }
14633       if (elt && TREE_CODE (elt) == TREE_LIST
14634           && TREE_VALUE (elt) == error_mark_node)
14635         error_seen = 1;
14636     }
14637
14638   if (error_seen)
14639     return error_mark_node;
14640
14641   /* Create a new type. We can't reuse the one we have here by
14642      patching its dimension because it originally is of dimension -1
14643      hence reused by gcc. This would prevent triangular arrays. */
14644   type = build_java_array_type (element_type, length);
14645   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14646   TREE_TYPE (node) = promote_type (type);
14647   TREE_CONSTANT (init) = all_constant;
14648   TREE_CONSTANT (node) = all_constant;
14649   return node;
14650 }
14651
14652 /* Verify that one entry of the initializer element list can be
14653    assigned to the array base type. Report 1 if an error occurred, 0
14654    otherwise.  */
14655
14656 static int
14657 array_constructor_check_entry (tree type, tree entry)
14658 {
14659   char *array_type_string = NULL;       /* For error reports */
14660   tree value, type_value, new_value, wfl_value, patched;
14661   int error_seen = 0;
14662
14663   new_value = NULL_TREE;
14664   wfl_value = TREE_VALUE (entry);
14665
14666   value = java_complete_tree (TREE_VALUE (entry));
14667   /* patch_string return error_mark_node if arg is error_mark_node */
14668   if ((patched = patch_string (value)))
14669     value = patched;
14670   if (value == error_mark_node)
14671     return 1;
14672
14673   type_value = TREE_TYPE (value);
14674
14675   /* At anytime, try_builtin_assignconv can report a warning on
14676      constant overflow during narrowing. */
14677   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14678   new_value = try_builtin_assignconv (wfl_operator, type, value);
14679   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14680     type_value = promote_type (type);
14681
14682   /* Check and report errors */
14683   if (!new_value)
14684     {
14685       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14686                    "Can't" : "Explicit cast needed to");
14687       if (!array_type_string)
14688         array_type_string = xstrdup (lang_printable_name (type, 1));
14689       parse_error_context
14690         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14691          msg, lang_printable_name (type_value, 1), array_type_string);
14692       error_seen = 1;
14693     }
14694
14695   if (new_value)
14696     TREE_VALUE (entry) = new_value;
14697
14698   if (array_type_string)
14699     free (array_type_string);
14700
14701   TREE_PURPOSE (entry) = NULL_TREE;
14702   return error_seen;
14703 }
14704
14705 static tree
14706 build_this (int location)
14707 {
14708   tree node = build_wfl_node (this_identifier_node);
14709   TREE_SET_CODE (node, THIS_EXPR);
14710   EXPR_WFL_LINECOL (node) = location;
14711   return node;
14712 }
14713
14714 /* 14.15 The return statement. It builds a modify expression that
14715    assigns the returned value to the RESULT_DECL that hold the value
14716    to be returned. */
14717
14718 static tree
14719 build_return (int location, tree op)
14720 {
14721   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14722   EXPR_WFL_LINECOL (node) = location;
14723   node = build_debugable_stmt (location, node);
14724   return node;
14725 }
14726
14727 static tree
14728 patch_return (tree node)
14729 {
14730   tree return_exp = TREE_OPERAND (node, 0);
14731   tree meth = current_function_decl;
14732   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14733   int error_found = 0;
14734
14735   TREE_TYPE (node) = error_mark_node;
14736   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14737
14738   /* It's invalid to have a return value within a function that is
14739      declared with the keyword void or that is a constructor */
14740   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14741     error_found = 1;
14742
14743   /* It's invalid to use a return statement in a static block */
14744   if (DECL_CLINIT_P (current_function_decl))
14745     error_found = 1;
14746
14747   /* It's invalid to have a no return value within a function that
14748      isn't declared with the keyword `void' */
14749   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14750     error_found = 2;
14751
14752   if (DECL_INSTINIT_P (current_function_decl))
14753     error_found = 1;
14754
14755   if (error_found)
14756     {
14757       if (DECL_INSTINIT_P (current_function_decl))
14758         parse_error_context (wfl_operator,
14759                              "`return' inside instance initializer");
14760
14761       else if (DECL_CLINIT_P (current_function_decl))
14762         parse_error_context (wfl_operator,
14763                              "`return' inside static initializer");
14764
14765       else if (!DECL_CONSTRUCTOR_P (meth))
14766         {
14767           char *t = xstrdup (lang_printable_name (mtype, 0));
14768           parse_error_context (wfl_operator,
14769                                "`return' with%s value from `%s %s'",
14770                                (error_found == 1 ? "" : "out"),
14771                                t, lang_printable_name (meth, 0));
14772           free (t);
14773         }
14774       else
14775         parse_error_context (wfl_operator,
14776                              "`return' with value from constructor `%s'",
14777                              lang_printable_name (meth, 0));
14778       return error_mark_node;
14779     }
14780
14781   /* If we have a return_exp, build a modify expression and expand
14782      it. Note: at that point, the assignment is declared valid, but we
14783      may want to carry some more hacks */
14784   if (return_exp)
14785     {
14786       tree exp = java_complete_tree (return_exp);
14787       tree modify, patched;
14788
14789       if ((patched = patch_string (exp)))
14790         exp = patched;
14791
14792       modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14793       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14794       modify = java_complete_tree (modify);
14795
14796       if (modify != error_mark_node)
14797         {
14798           TREE_SIDE_EFFECTS (modify) = 1;
14799           TREE_OPERAND (node, 0) = modify;
14800         }
14801       else
14802         return error_mark_node;
14803     }
14804   TREE_TYPE (node) = void_type_node;
14805   TREE_SIDE_EFFECTS (node) = 1;
14806   return node;
14807 }
14808
14809 /* 14.8 The if Statement */
14810
14811 static tree
14812 build_if_else_statement (int location, tree expression, tree if_body,
14813                          tree else_body)
14814 {
14815   tree node;
14816   if (!else_body)
14817     else_body = empty_stmt_node;
14818   node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14819   EXPR_WFL_LINECOL (node) = location;
14820   node = build_debugable_stmt (location, node);
14821   return node;
14822 }
14823
14824 static tree
14825 patch_if_else_statement (tree node)
14826 {
14827   tree expression = TREE_OPERAND (node, 0);
14828   int can_complete_normally
14829     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14830        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14831
14832   TREE_TYPE (node) = error_mark_node;
14833   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14834
14835   /* The type of expression must be boolean */
14836   if (TREE_TYPE (expression) != boolean_type_node
14837       && TREE_TYPE (expression) != promoted_boolean_type_node)
14838     {
14839       parse_error_context
14840         (wfl_operator,
14841          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14842          lang_printable_name (TREE_TYPE (expression), 0));
14843       return error_mark_node;
14844     }
14845
14846   if (TREE_CODE (expression) == INTEGER_CST)
14847     {
14848       if (integer_zerop (expression))
14849         node = TREE_OPERAND (node, 2);
14850       else
14851         node = TREE_OPERAND (node, 1);
14852       if (CAN_COMPLETE_NORMALLY (node) != can_complete_normally)
14853         {
14854           node = build (COMPOUND_EXPR, void_type_node, node, empty_stmt_node);
14855           CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14856         }
14857       return node;
14858     }
14859   TREE_TYPE (node) = void_type_node;
14860   TREE_SIDE_EFFECTS (node) = 1;
14861   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14862   return node;
14863 }
14864
14865 /* 14.6 Labeled Statements */
14866
14867 /* Action taken when a labeled statement is parsed. a new
14868    LABELED_BLOCK_EXPR is created. No statement is attached to the
14869    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14870
14871 static tree
14872 build_labeled_block (int location, tree label)
14873 {
14874   tree label_name ;
14875   tree label_decl, node;
14876   if (label == NULL_TREE || label == continue_identifier_node)
14877     label_name = label;
14878   else
14879     {
14880       label_name = merge_qualified_name (label_id, label);
14881       /* Issue an error if we try to reuse a label that was previously
14882          declared */
14883       if (IDENTIFIER_LOCAL_VALUE (label_name))
14884         {
14885           EXPR_WFL_LINECOL (wfl_operator) = location;
14886           parse_error_context (wfl_operator,
14887             "Declaration of `%s' shadows a previous label declaration",
14888                                IDENTIFIER_POINTER (label));
14889           EXPR_WFL_LINECOL (wfl_operator) =
14890             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14891           parse_error_context (wfl_operator,
14892             "This is the location of the previous declaration of label `%s'",
14893                                IDENTIFIER_POINTER (label));
14894           java_error_count--;
14895         }
14896     }
14897
14898   label_decl = create_label_decl (label_name);
14899   node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14900   EXPR_WFL_LINECOL (node) = location;
14901   TREE_SIDE_EFFECTS (node) = 1;
14902   return node;
14903 }
14904
14905 /* A labeled statement LBE is attached a statement.  */
14906
14907 static tree
14908 finish_labeled_statement (tree lbe, /* Labeled block expr */
14909                           tree statement)
14910 {
14911   /* In anyways, tie the loop to its statement */
14912   LABELED_BLOCK_BODY (lbe) = statement;
14913   pop_labeled_block ();
14914   POP_LABELED_BLOCK ();
14915   return lbe;
14916 }
14917
14918 /* 14.10, 14.11, 14.12 Loop Statements */
14919
14920 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14921    list. */
14922
14923 static tree
14924 build_new_loop (tree loop_body)
14925 {
14926   tree loop =  build (LOOP_EXPR, NULL_TREE, loop_body);
14927   TREE_SIDE_EFFECTS (loop) = 1;
14928   PUSH_LOOP (loop);
14929   return loop;
14930 }
14931
14932 /* Create a loop body according to the following structure:
14933      COMPOUND_EXPR
14934        COMPOUND_EXPR            (loop main body)
14935          EXIT_EXPR              (this order is for while/for loops.
14936          LABELED_BLOCK_EXPR      the order is reversed for do loops)
14937            LABEL_DECL           (a continue occurring here branches at the
14938            BODY                  end of this labeled block)
14939        INCREMENT                (if any)
14940
14941   REVERSED, if nonzero, tells that the loop condition expr comes
14942   after the body, like in the do-while loop.
14943
14944   To obtain a loop, the loop body structure described above is
14945   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14946
14947    LABELED_BLOCK_EXPR
14948      LABEL_DECL                   (use this label to exit the loop)
14949      LOOP_EXPR
14950        <structure described above> */
14951
14952 static tree
14953 build_loop_body (int location, tree condition, int reversed)
14954 {
14955   tree first, second, body;
14956
14957   condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14958   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14959   condition = build_debugable_stmt (location, condition);
14960   TREE_SIDE_EFFECTS (condition) = 1;
14961
14962   body = build_labeled_block (0, continue_identifier_node);
14963   first = (reversed ? body : condition);
14964   second = (reversed ? condition : body);
14965   return
14966     build (COMPOUND_EXPR, NULL_TREE,
14967            build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
14968 }
14969
14970 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14971    their order) on the current loop. Unlink the current loop from the
14972    loop list.  */
14973
14974 static tree
14975 finish_loop_body (int location, tree condition, tree body, int reversed)
14976 {
14977   tree to_return = ctxp->current_loop;
14978   tree loop_body = LOOP_EXPR_BODY (to_return);
14979   if (condition)
14980     {
14981       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14982       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14983          The real EXIT_EXPR is one operand further. */
14984       EXPR_WFL_LINECOL (cnode) = location;
14985       /* This one is for accurate error reports */
14986       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14987       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14988     }
14989   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14990   POP_LOOP ();
14991   return to_return;
14992 }
14993
14994 /* Tailored version of finish_loop_body for FOR loops, when FOR
14995    loops feature the condition part */
14996
14997 static tree
14998 finish_for_loop (int location, tree condition, tree update, tree body)
14999 {
15000   /* Put the condition and the loop body in place */
15001   tree loop = finish_loop_body (location, condition, body, 0);
15002   /* LOOP is the current loop which has been now popped of the loop
15003      stack.  Mark the update block as reachable and install it.  We do
15004      this because the (current interpretation of the) JLS requires
15005      that the update expression be considered reachable even if the
15006      for loop's body doesn't complete normally.  */
15007   if (update != NULL_TREE && update != empty_stmt_node)
15008     {
15009       tree up2 = update;
15010       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
15011         up2 = EXPR_WFL_NODE (up2);
15012       /* It is possible for the update expression to be an
15013          EXPR_WFL_NODE wrapping nothing.  */
15014       if (up2 != NULL_TREE && up2 != empty_stmt_node)
15015         {
15016           /* Try to detect constraint violations.  These would be
15017              programming errors somewhere.  */
15018           if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
15019               || TREE_CODE (up2) == LOOP_EXPR)
15020             abort ();
15021           SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
15022         }
15023     }
15024   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
15025   return loop;
15026 }
15027
15028 /* Try to find the loop a block might be related to. This comprises
15029    the case where the LOOP_EXPR is found as the second operand of a
15030    COMPOUND_EXPR, because the loop happens to have an initialization
15031    part, then expressed as the first operand of the COMPOUND_EXPR. If
15032    the search finds something, 1 is returned. Otherwise, 0 is
15033    returned. The search is assumed to start from a
15034    LABELED_BLOCK_EXPR's block.  */
15035
15036 static tree
15037 search_loop (tree statement)
15038 {
15039   if (TREE_CODE (statement) == LOOP_EXPR)
15040     return statement;
15041
15042   if (TREE_CODE (statement) == BLOCK)
15043     statement = BLOCK_SUBBLOCKS (statement);
15044   else
15045     return NULL_TREE;
15046
15047   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15048     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15049       statement = TREE_OPERAND (statement, 1);
15050
15051   return (TREE_CODE (statement) == LOOP_EXPR
15052           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
15053 }
15054
15055 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15056    returned otherwise.  */
15057
15058 static int
15059 labeled_block_contains_loop_p (tree block, tree loop)
15060 {
15061   if (!block)
15062     return 0;
15063
15064   if (LABELED_BLOCK_BODY (block) == loop)
15065     return 1;
15066
15067   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
15068     return 1;
15069
15070   return 0;
15071 }
15072
15073 /* If the loop isn't surrounded by a labeled statement, create one and
15074    insert LOOP as its body.  */
15075
15076 static tree
15077 patch_loop_statement (tree loop)
15078 {
15079   tree loop_label;
15080
15081   TREE_TYPE (loop) = void_type_node;
15082   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
15083     return loop;
15084
15085   loop_label = build_labeled_block (0, NULL_TREE);
15086   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15087      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15088   LABELED_BLOCK_BODY (loop_label) = loop;
15089   PUSH_LABELED_BLOCK (loop_label);
15090   return loop_label;
15091 }
15092
15093 /* 14.13, 14.14: break and continue Statements */
15094
15095 /* Build a break or a continue statement. a null NAME indicates an
15096    unlabeled break/continue statement.  */
15097
15098 static tree
15099 build_bc_statement (int location, int is_break, tree name)
15100 {
15101   tree break_continue, label_block_expr = NULL_TREE;
15102
15103   if (name)
15104     {
15105       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15106             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15107         /* Null means that we don't have a target for this named
15108            break/continue. In this case, we make the target to be the
15109            label name, so that the error can be reported accurately in
15110            patch_bc_statement. */
15111         label_block_expr = EXPR_WFL_NODE (name);
15112     }
15113   /* Unlabeled break/continue will be handled during the
15114      break/continue patch operation */
15115   break_continue
15116     = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
15117
15118   IS_BREAK_STMT_P (break_continue) = is_break;
15119   TREE_SIDE_EFFECTS (break_continue) = 1;
15120   EXPR_WFL_LINECOL (break_continue) = location;
15121   break_continue = build_debugable_stmt (location, break_continue);
15122   return break_continue;
15123 }
15124
15125 /* Verification of a break/continue statement. */
15126
15127 static tree
15128 patch_bc_statement (tree node)
15129 {
15130   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15131   tree labeled_block = ctxp->current_labeled_block;
15132   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15133
15134   /* Having an identifier here means that the target is unknown. */
15135   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15136     {
15137       parse_error_context (wfl_operator, "No label definition found for `%s'",
15138                            IDENTIFIER_POINTER (bc_label));
15139       return error_mark_node;
15140     }
15141   if (! IS_BREAK_STMT_P (node))
15142     {
15143       /* It's a continue statement. */
15144       for (;; labeled_block = TREE_CHAIN (labeled_block))
15145         {
15146           if (labeled_block == NULL_TREE)
15147             {
15148               if (bc_label == NULL_TREE)
15149                 parse_error_context (wfl_operator,
15150                                      "`continue' must be in loop");
15151               else
15152                 parse_error_context
15153                   (wfl_operator, "continue label `%s' does not name a loop",
15154                    IDENTIFIER_POINTER (bc_label));
15155               return error_mark_node;
15156             }
15157           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15158                == continue_identifier_node)
15159               && (bc_label == NULL_TREE
15160                   || TREE_CHAIN (labeled_block) == bc_label))
15161             {
15162               bc_label = labeled_block;
15163               break;
15164             }
15165         }
15166     }
15167   else if (!bc_label)
15168     {
15169       for (;; labeled_block = TREE_CHAIN (labeled_block))
15170         {
15171           if (labeled_block == NULL_TREE)
15172             {
15173               parse_error_context (wfl_operator,
15174                                      "`break' must be in loop or switch");
15175               return error_mark_node;
15176             }
15177           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15178           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15179               || search_loop (target_stmt))
15180             {
15181               bc_label = labeled_block;
15182               break;
15183             }
15184         }
15185     }
15186
15187   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15188   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15189
15190   /* Our break/continue don't return values. */
15191   TREE_TYPE (node) = void_type_node;
15192   /* Encapsulate the break within a compound statement so that it's
15193      expanded all the times by expand_expr (and not clobbered
15194      sometimes, like after a if statement) */
15195   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15196   TREE_SIDE_EFFECTS (node) = 1;
15197   return node;
15198 }
15199
15200 /* Process the exit expression belonging to a loop. Its type must be
15201    boolean.  */
15202
15203 static tree
15204 patch_exit_expr (tree node)
15205 {
15206   tree expression = TREE_OPERAND (node, 0);
15207   TREE_TYPE (node) = error_mark_node;
15208   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15209
15210   /* The type of expression must be boolean */
15211   if (TREE_TYPE (expression) != boolean_type_node)
15212     {
15213       parse_error_context
15214         (wfl_operator,
15215     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15216          lang_printable_name (TREE_TYPE (expression), 0));
15217       return error_mark_node;
15218     }
15219   /* Now we know things are allright, invert the condition, fold and
15220      return */
15221   TREE_OPERAND (node, 0) =
15222     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15223
15224   if (! integer_zerop (TREE_OPERAND (node, 0))
15225       && ctxp->current_loop != NULL_TREE
15226       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15227     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15228   if (! integer_onep (TREE_OPERAND (node, 0)))
15229     CAN_COMPLETE_NORMALLY (node) = 1;
15230
15231
15232   TREE_TYPE (node) = void_type_node;
15233   return node;
15234 }
15235
15236 /* 14.9 Switch statement */
15237
15238 static tree
15239 patch_switch_statement (tree node)
15240 {
15241   tree se = TREE_OPERAND (node, 0), se_type;
15242   tree save, iter;
15243
15244   /* Complete the switch expression */
15245   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15246   se_type = TREE_TYPE (se);
15247   /* The type of the switch expression must be char, byte, short or
15248      int */
15249   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15250     {
15251       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15252       parse_error_context (wfl_operator,
15253           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15254                            lang_printable_name (se_type, 0));
15255       /* This is what java_complete_tree will check */
15256       TREE_OPERAND (node, 0) = error_mark_node;
15257       return error_mark_node;
15258     }
15259
15260   /* Save and restore the outer case label list.  */
15261   save = case_label_list;
15262   case_label_list = NULL_TREE;
15263
15264   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15265
15266   /* See if we've found a duplicate label.  We can't leave this until
15267      code generation, because in `--syntax-only' and `-C' modes we
15268      don't do ordinary code generation.  */
15269   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15270     {
15271       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15272       tree subiter;
15273       for (subiter = TREE_CHAIN (iter);
15274            subiter != NULL_TREE;
15275            subiter = TREE_CHAIN (subiter))
15276         {
15277           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15278           if (val == subval)
15279             {
15280               EXPR_WFL_LINECOL (wfl_operator)
15281                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15282               /* The case_label_list is in reverse order, so print the
15283                  outer label first.  */
15284               parse_error_context (wfl_operator, "duplicate case label: `"
15285                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15286               EXPR_WFL_LINECOL (wfl_operator)
15287                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15288               parse_error_context (wfl_operator, "original label is here");
15289
15290               break;
15291             }
15292         }
15293     }
15294
15295   case_label_list = save;
15296
15297   /* Ready to return */
15298   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15299     {
15300       TREE_TYPE (node) = error_mark_node;
15301       return error_mark_node;
15302     }
15303   TREE_TYPE (node) = void_type_node;
15304   TREE_SIDE_EFFECTS (node) = 1;
15305   CAN_COMPLETE_NORMALLY (node)
15306     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15307       || ! SWITCH_HAS_DEFAULT (node);
15308   return node;
15309 }
15310
15311 /* Assertions.  */
15312
15313 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15314    might be NULL_TREE.  */
15315 static tree
15316 build_assertion (int location, tree condition, tree value)
15317 {
15318   tree node;
15319   tree klass = GET_CPC ();
15320
15321   if (! enable_assertions (klass))
15322     {
15323       condition = build (TRUTH_ANDIF_EXPR, NULL_TREE,
15324                          boolean_false_node, condition);
15325       if (value == NULL_TREE)
15326         value = empty_stmt_node;
15327       return build_if_else_statement (location, condition,
15328                                       value, NULL_TREE);
15329     }
15330
15331   if (! CLASS_USES_ASSERTIONS (klass))
15332     {
15333       tree field, classdollar, id, call;
15334       tree class_type = TREE_TYPE (klass);
15335
15336       field = add_field (class_type,
15337                          get_identifier ("$assertionsDisabled"),
15338                          boolean_type_node,
15339                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15340       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15341       FIELD_SYNTHETIC (field) = 1;
15342
15343       classdollar = build_incomplete_class_ref (location, class_type);
15344
15345       /* Call CLASS.desiredAssertionStatus().  */
15346       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15347       call = build (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15348       call = make_qualified_primary (classdollar, call, location);
15349       TREE_SIDE_EFFECTS (call) = 1;
15350
15351       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15352          seem odd, but we do it to generate code identical to that of
15353          the JDK.  */
15354       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15355       TREE_SIDE_EFFECTS (call) = 1;
15356       DECL_INITIAL (field) = call;
15357
15358       /* Record the initializer in the initializer statement list.  */
15359       call = build (MODIFY_EXPR, NULL_TREE, field, call);
15360       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15361       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15362       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15363
15364       CLASS_USES_ASSERTIONS (klass) = 1;
15365     }
15366
15367   if (value != NULL_TREE)
15368     value = tree_cons (NULL_TREE, value, NULL_TREE);
15369
15370   node = build_wfl_node (get_identifier ("java"));
15371   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15372                               location);
15373   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15374                               location);
15375
15376   node = build (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15377   TREE_SIDE_EFFECTS (node) = 1;
15378   /* It is too early to use BUILD_THROW.  */
15379   node = build1 (THROW_EXPR, NULL_TREE, node);
15380   TREE_SIDE_EFFECTS (node) = 1;
15381
15382   /* We invert the condition; if we just put NODE as the `else' part
15383      then we generate weird-looking bytecode.  */
15384   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15385   /* Check $assertionsDisabled.  */
15386   condition
15387     = build (TRUTH_ANDIF_EXPR, NULL_TREE,
15388              build1 (TRUTH_NOT_EXPR, NULL_TREE,
15389                      build_wfl_node (get_identifier ("$assertionsDisabled"))),
15390              condition);
15391   node = build_if_else_statement (location, condition, node, NULL_TREE);
15392   return node;
15393 }
15394
15395 /* 14.18 The try/catch statements */
15396
15397 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15398    catches TYPE and executes CATCH_STMTS.  */
15399
15400 static tree
15401 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15402                             tree catch_stmts)
15403 {
15404   tree try_block, catch_clause_param, catch_block, catch;
15405
15406   /* First build a try block */
15407   try_block = build_expr_block (try_stmts, NULL_TREE);
15408
15409   /* Build a catch block: we need a catch clause parameter */
15410   if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15411     {
15412       tree catch_type = obtain_incomplete_type (type_or_name);
15413       jdep *dep;
15414       catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15415       register_incomplete_type (JDEP_VARIABLE, type_or_name,
15416                                 catch_clause_param, catch_type);
15417       dep = CLASSD_LAST (ctxp->classd_list);
15418       JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15419     }
15420   else
15421     catch_clause_param = build_decl (VAR_DECL, wpv_id,
15422                                      build_pointer_type (type_or_name));
15423
15424   /* And a block */
15425   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15426
15427   /* Initialize the variable and store in the block */
15428   catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15429                  build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15430   add_stmt_to_block (catch_block, NULL_TREE, catch);
15431
15432   /* Add the catch statements */
15433   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15434
15435   /* Now we can build a CATCH_EXPR */
15436   catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
15437
15438   return build_try_statement (location, try_block, catch_block);
15439 }
15440
15441 static tree
15442 build_try_statement (int location, tree try_block, tree catches)
15443 {
15444   tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
15445   EXPR_WFL_LINECOL (node) = location;
15446   return node;
15447 }
15448
15449 static tree
15450 build_try_finally_statement (int location, tree try_block, tree finally)
15451 {
15452   tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15453   EXPR_WFL_LINECOL (node) = location;
15454   return node;
15455 }
15456
15457 static tree
15458 patch_try_statement (tree node)
15459 {
15460   int error_found = 0;
15461   tree try = TREE_OPERAND (node, 0);
15462   /* Exception handlers are considered in left to right order */
15463   tree catch = nreverse (TREE_OPERAND (node, 1));
15464   tree current, caught_type_list = NULL_TREE;
15465
15466   /* Check catch clauses, if any. Every time we find an error, we try
15467      to process the next catch clause. We process the catch clause before
15468      the try block so that when processing the try block we can check thrown
15469      exceptions againts the caught type list. */
15470   for (current = catch; current; current = TREE_CHAIN (current))
15471     {
15472       tree carg_decl, carg_type;
15473       tree sub_current, catch_block, catch_clause;
15474       int unreachable;
15475
15476       /* At this point, the structure of the catch clause is
15477            CATCH_EXPR           (catch node)
15478              BLOCK              (with the decl of the parameter)
15479                COMPOUND_EXPR
15480                  MODIFY_EXPR   (assignment of the catch parameter)
15481                  BLOCK          (catch clause block)
15482        */
15483       catch_clause = TREE_OPERAND (current, 0);
15484       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15485       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15486
15487       /* Catch clauses can't have more than one parameter declared,
15488          but it's already enforced by the grammar. Make sure that the
15489          only parameter of the clause statement in of class Throwable
15490          or a subclass of Throwable, but that was done earlier. The
15491          catch clause parameter type has also been resolved. */
15492
15493       /* Just make sure that the catch clause parameter type inherits
15494          from java.lang.Throwable */
15495       if (!inherits_from_p (carg_type, throwable_type_node))
15496         {
15497           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15498           parse_error_context (wfl_operator,
15499                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15500                                lang_printable_name (carg_type, 0));
15501           error_found = 1;
15502           continue;
15503         }
15504
15505       /* Partial check for unreachable catch statement: The catch
15506          clause is reachable iff is no earlier catch block A in
15507          the try statement such that the type of the catch
15508          clause's parameter is the same as or a subclass of the
15509          type of A's parameter */
15510       unreachable = 0;
15511       for (sub_current = catch;
15512            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15513         {
15514           tree sub_catch_clause, decl;
15515           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15516           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15517
15518           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15519             {
15520               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15521               parse_error_context
15522                 (wfl_operator,
15523                  "`catch' not reached because of the catch clause at line %d",
15524                  EXPR_WFL_LINENO (sub_current));
15525               unreachable = error_found = 1;
15526               break;
15527             }
15528         }
15529       /* Complete the catch clause block */
15530       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15531       if (catch_block == error_mark_node)
15532         {
15533           error_found = 1;
15534           continue;
15535         }
15536       if (CAN_COMPLETE_NORMALLY (catch_block))
15537         CAN_COMPLETE_NORMALLY (node) = 1;
15538       TREE_OPERAND (current, 0) = catch_block;
15539
15540       if (unreachable)
15541         continue;
15542
15543       /* Things to do here: the exception must be thrown */
15544
15545       /* Link this type to the caught type list */
15546       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15547     }
15548
15549   PUSH_EXCEPTIONS (caught_type_list);
15550   if ((try = java_complete_tree (try)) == error_mark_node)
15551     error_found = 1;
15552   if (CAN_COMPLETE_NORMALLY (try))
15553     CAN_COMPLETE_NORMALLY (node) = 1;
15554   POP_EXCEPTIONS ();
15555
15556   /* Verification ends here */
15557   if (error_found)
15558     return error_mark_node;
15559
15560   TREE_OPERAND (node, 0) = try;
15561   TREE_OPERAND (node, 1) = catch;
15562   TREE_TYPE (node) = void_type_node;
15563   return node;
15564 }
15565
15566 /* 14.17 The synchronized Statement */
15567
15568 static tree
15569 patch_synchronized_statement (tree node, tree wfl_op1)
15570 {
15571   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15572   tree block = TREE_OPERAND (node, 1);
15573
15574   tree tmp, enter, exit, expr_decl, assignment;
15575
15576   if (expr == error_mark_node)
15577     {
15578       block = java_complete_tree (block);
15579       return expr;
15580     }
15581
15582   /* We might be trying to synchronize on a STRING_CST */
15583   if ((tmp = patch_string (expr)))
15584     expr = tmp;
15585
15586   /* The TYPE of expr must be a reference type */
15587   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15588     {
15589       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15590       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15591                            lang_printable_name (TREE_TYPE (expr), 0));
15592       return error_mark_node;
15593     }
15594
15595   if (flag_emit_xref)
15596     {
15597       TREE_OPERAND (node, 0) = expr;
15598       TREE_OPERAND (node, 1) = java_complete_tree (block);
15599       CAN_COMPLETE_NORMALLY (node) = 1;
15600       return node;
15601     }
15602
15603   /* Generate a try-finally for the synchronized statement, except
15604      that the handler that catches all throw exception calls
15605      _Jv_MonitorExit and then rethrow the exception.
15606      The synchronized statement is then implemented as:
15607      TRY
15608        {
15609          _Jv_MonitorEnter (expression)
15610          synchronized_block
15611          _Jv_MonitorExit (expression)
15612        }
15613      CATCH_ALL
15614        {
15615          e = _Jv_exception_info ();
15616          _Jv_MonitorExit (expression)
15617          Throw (e);
15618        } */
15619
15620   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15621   BUILD_MONITOR_ENTER (enter, expr_decl);
15622   BUILD_MONITOR_EXIT (exit, expr_decl);
15623   CAN_COMPLETE_NORMALLY (enter) = 1;
15624   CAN_COMPLETE_NORMALLY (exit) = 1;
15625   assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15626   TREE_SIDE_EFFECTS (assignment) = 1;
15627   node = build (COMPOUND_EXPR, NULL_TREE,
15628                 build (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15629                 build (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15630   node = build_expr_block (node, expr_decl);
15631
15632   return java_complete_tree (node);
15633 }
15634
15635 /* 14.16 The throw Statement */
15636
15637 static tree
15638 patch_throw_statement (tree node, tree wfl_op1)
15639 {
15640   tree expr = TREE_OPERAND (node, 0);
15641   tree type = TREE_TYPE (expr);
15642   int unchecked_ok = 0, tryblock_throws_ok = 0;
15643
15644   /* Thrown expression must be assignable to java.lang.Throwable */
15645   if (!try_reference_assignconv (throwable_type_node, expr))
15646     {
15647       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15648       parse_error_context (wfl_operator,
15649     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15650                            lang_printable_name (type, 0));
15651       /* If the thrown expression was a reference, we further the
15652          compile-time check. */
15653       if (!JREFERENCE_TYPE_P (type))
15654         return error_mark_node;
15655     }
15656
15657   /* At least one of the following must be true */
15658
15659   /* The type of the throw expression is a not checked exception,
15660      i.e. is a unchecked expression. */
15661   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15662
15663   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15664   /* An instance can't throw a checked exception unless that exception
15665      is explicitly declared in the `throws' clause of each
15666      constructor. This doesn't apply to anonymous classes, since they
15667      don't have declared constructors. */
15668   if (!unchecked_ok
15669       && DECL_INSTINIT_P (current_function_decl)
15670       && !ANONYMOUS_CLASS_P (current_class))
15671     {
15672       tree current;
15673       for (current = TYPE_METHODS (current_class); current;
15674            current = TREE_CHAIN (current))
15675         if (DECL_CONSTRUCTOR_P (current)
15676             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15677           {
15678             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)",
15679                                  lang_printable_name (TREE_TYPE (expr), 0));
15680             return error_mark_node;
15681           }
15682     }
15683
15684   /* Throw is contained in a try statement and at least one catch
15685      clause can receive the thrown expression or the current method is
15686      declared to throw such an exception. Or, the throw statement is
15687      contained in a method or constructor declaration and the type of
15688      the Expression is assignable to at least one type listed in the
15689      throws clause the declaration. */
15690   if (!unchecked_ok)
15691     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15692   if (!(unchecked_ok || tryblock_throws_ok))
15693     {
15694       /* If there is a surrounding try block that has no matching
15695          clatch clause, report it first. A surrounding try block exits
15696          only if there is something after the list of checked
15697          exception thrown by the current function (if any). */
15698       if (IN_TRY_BLOCK_P ())
15699         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15700                              lang_printable_name (type, 0));
15701       /* If we have no surrounding try statement and the method doesn't have
15702          any throws, report it now. FIXME */
15703
15704       /* We report that the exception can't be throw from a try block
15705          in all circumstances but when the `throw' is inside a static
15706          block. */
15707       else if (!EXCEPTIONS_P (currently_caught_type_list)
15708                && !tryblock_throws_ok)
15709         {
15710           if (DECL_CLINIT_P (current_function_decl))
15711             parse_error_context (wfl_operator,
15712                    "Checked exception `%s' can't be thrown in initializer",
15713                                  lang_printable_name (type, 0));
15714           else
15715             parse_error_context (wfl_operator,
15716                    "Checked exception `%s' isn't thrown from a `try' block",
15717                                  lang_printable_name (type, 0));
15718         }
15719       /* Otherwise, the current method doesn't have the appropriate
15720          throws declaration */
15721       else
15722         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15723                              lang_printable_name (type, 0));
15724       return error_mark_node;
15725     }
15726
15727   if (! flag_emit_class_files && ! flag_emit_xref)
15728     BUILD_THROW (node, expr);
15729
15730   /* If doing xrefs, keep the location where the `throw' was seen. */
15731   if (flag_emit_xref)
15732     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15733   return node;
15734 }
15735
15736 /* Check that exception said to be thrown by method DECL can be
15737    effectively caught from where DECL is invoked.  THIS_EXPR is the
15738    expression that computes `this' for the method call.  */
15739 static void
15740 check_thrown_exceptions (int location, tree decl, tree this_expr)
15741 {
15742   tree throws;
15743   int is_array_call = 0;
15744
15745   /* Skip check within generated methods, such as access$<n>.  */
15746   if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
15747     return;
15748
15749   if (this_expr != NULL_TREE
15750       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15751       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15752     is_array_call = 1;
15753
15754   /* For all the unchecked exceptions thrown by DECL.  */
15755   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15756        throws = TREE_CHAIN (throws))
15757     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15758       {
15759         /* Suppress errors about cloning arrays.  */
15760         if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15761           continue;
15762
15763         EXPR_WFL_LINECOL (wfl_operator) = location;
15764         if (DECL_FINIT_P (current_function_decl))
15765           parse_error_context
15766             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15767              lang_printable_name (TREE_VALUE (throws), 0));
15768         else
15769           {
15770             parse_error_context
15771               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15772                lang_printable_name (TREE_VALUE (throws), 0),
15773                (DECL_INIT_P (current_function_decl) ?
15774                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15775                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15776           }
15777       }
15778 }
15779
15780 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15781    try-catch blocks, OR is listed in the `throws' clause of the
15782    current method.  */
15783
15784 static int
15785 check_thrown_exceptions_do (tree exception)
15786 {
15787   tree list = currently_caught_type_list;
15788   resolve_and_layout (exception, NULL_TREE);
15789   /* First, all the nested try-catch-finally at that stage. The
15790      last element contains `throws' clause exceptions, if any. */
15791   if (IS_UNCHECKED_EXCEPTION_P (exception))
15792     return 1;
15793   while (list)
15794     {
15795       tree caught;
15796       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15797         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15798           return 1;
15799       list = TREE_CHAIN (list);
15800     }
15801   return 0;
15802 }
15803
15804 static void
15805 purge_unchecked_exceptions (tree mdecl)
15806 {
15807   tree throws = DECL_FUNCTION_THROWS (mdecl);
15808   tree new = NULL_TREE;
15809
15810   while (throws)
15811     {
15812       tree next = TREE_CHAIN (throws);
15813       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15814         {
15815           TREE_CHAIN (throws) = new;
15816           new = throws;
15817         }
15818       throws = next;
15819     }
15820   /* List is inverted here, but it doesn't matter */
15821   DECL_FUNCTION_THROWS (mdecl) = new;
15822 }
15823
15824 /* This function goes over all of CLASS_TYPE ctors and checks whether
15825    each of them features at least one unchecked exception in its
15826    `throws' clause. If it's the case, it returns `true', `false'
15827    otherwise.  */
15828
15829 static bool
15830 ctors_unchecked_throws_clause_p (tree class_type)
15831 {
15832   tree current;
15833
15834   for (current = TYPE_METHODS (class_type); current;
15835        current = TREE_CHAIN (current))
15836     {
15837       bool ctu = false; /* Ctor Throws Unchecked */
15838       if (DECL_CONSTRUCTOR_P (current))
15839         {
15840           tree throws;
15841           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15842                throws = TREE_CHAIN (throws))
15843             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15844               ctu = true;
15845         }
15846       /* We return false as we found one ctor that is unfit. */
15847       if (!ctu && DECL_CONSTRUCTOR_P (current))
15848         return false;
15849     }
15850   /* All ctors feature at least one unchecked exception in their
15851      `throws' clause. */
15852   return true;
15853 }
15854
15855 /* 15.24 Conditional Operator ?: */
15856
15857 static tree
15858 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15859 {
15860   tree cond = TREE_OPERAND (node, 0);
15861   tree op1 = TREE_OPERAND (node, 1);
15862   tree op2 = TREE_OPERAND (node, 2);
15863   tree resulting_type = NULL_TREE;
15864   tree t1, t2, patched;
15865   int error_found = 0;
15866
15867   /* Operands of ?: might be StringBuffers crafted as a result of a
15868      string concatenation. Obtain a descent operand here.  */
15869   if ((patched = patch_string (op1)))
15870     TREE_OPERAND (node, 1) = op1 = patched;
15871   if ((patched = patch_string (op2)))
15872     TREE_OPERAND (node, 2) = op2 = patched;
15873
15874   t1 = TREE_TYPE (op1);
15875   t2 = TREE_TYPE (op2);
15876
15877   /* The first expression must be a boolean */
15878   if (TREE_TYPE (cond) != boolean_type_node)
15879     {
15880       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15881       parse_error_context (wfl_operator,
15882                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15883                            lang_printable_name (TREE_TYPE (cond), 0));
15884       error_found = 1;
15885     }
15886
15887   /* Second and third can be numeric, boolean (i.e. primitive),
15888      references or null. Anything else results in an error */
15889   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15890         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15891             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15892         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15893     error_found = 1;
15894
15895   /* Determine the type of the conditional expression. Same types are
15896      easy to deal with */
15897   else if (t1 == t2)
15898     resulting_type = t1;
15899
15900   /* There are different rules for numeric types */
15901   else if (JNUMERIC_TYPE_P (t1))
15902     {
15903       /* if byte/short found, the resulting type is short */
15904       if ((t1 == byte_type_node && t2 == short_type_node)
15905           || (t1 == short_type_node && t2 == byte_type_node))
15906         resulting_type = short_type_node;
15907
15908       /* If t1 is a constant int and t2 is of type byte, short or char
15909          and t1's value fits in t2, then the resulting type is t2 */
15910       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15911           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15912         resulting_type = t2;
15913
15914       /* If t2 is a constant int and t1 is of type byte, short or char
15915          and t2's value fits in t1, then the resulting type is t1 */
15916       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15917           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15918         resulting_type = t1;
15919
15920       /* Otherwise, binary numeric promotion is applied and the
15921          resulting type is the promoted type of operand 1 and 2 */
15922       else
15923         resulting_type = binary_numeric_promotion (t1, t2,
15924                                                    &TREE_OPERAND (node, 1),
15925                                                    &TREE_OPERAND (node, 2));
15926     }
15927
15928   /* Cases of a reference and a null type */
15929   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15930     resulting_type = t1;
15931
15932   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15933     resulting_type = t2;
15934
15935   /* Last case: different reference types. If a type can be converted
15936      into the other one by assignment conversion, the latter
15937      determines the type of the expression */
15938   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15939     resulting_type = promote_type (t1);
15940
15941   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15942     resulting_type = promote_type (t2);
15943
15944   /* If we don't have any resulting type, we're in trouble */
15945   if (!resulting_type)
15946     {
15947       char *t = xstrdup (lang_printable_name (t1, 0));
15948       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15949       parse_error_context (wfl_operator,
15950                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15951                            t, lang_printable_name (t2, 0));
15952       free (t);
15953       error_found = 1;
15954     }
15955
15956   if (error_found)
15957     {
15958       TREE_TYPE (node) = error_mark_node;
15959       return error_mark_node;
15960     }
15961
15962   TREE_TYPE (node) = resulting_type;
15963   TREE_SET_CODE (node, COND_EXPR);
15964   CAN_COMPLETE_NORMALLY (node) = 1;
15965   return node;
15966 }
15967
15968 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15969
15970 static tree
15971 maybe_build_class_init_for_field (tree decl, tree expr)
15972 {
15973   tree clas = DECL_CONTEXT (decl);
15974   if (flag_emit_class_files || flag_emit_xref)
15975     return expr;
15976
15977   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
15978       && FIELD_FINAL (decl))
15979     {
15980       tree init = DECL_INITIAL (decl);
15981       if (init != NULL_TREE)
15982         init = fold_constant_for_init (init, decl);
15983       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
15984         return expr;
15985     }
15986
15987   return build_class_init (clas, expr);
15988 }
15989
15990 /* Try to constant fold NODE.
15991    If NODE is not a constant expression, return NULL_EXPR.
15992    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15993
15994 static tree
15995 fold_constant_for_init (tree node, tree context)
15996 {
15997   tree op0, op1, val;
15998   enum tree_code code = TREE_CODE (node);
15999
16000   switch (code)
16001     {
16002     case INTEGER_CST:
16003       if (node == null_pointer_node)
16004         return NULL_TREE;
16005     case STRING_CST:
16006     case REAL_CST:
16007       return node;
16008
16009     case PLUS_EXPR:
16010     case MINUS_EXPR:
16011     case MULT_EXPR:
16012     case TRUNC_MOD_EXPR:
16013     case RDIV_EXPR:
16014     case LSHIFT_EXPR:
16015     case RSHIFT_EXPR:
16016     case URSHIFT_EXPR:
16017     case BIT_AND_EXPR:
16018     case BIT_XOR_EXPR:
16019     case BIT_IOR_EXPR:
16020     case TRUTH_ANDIF_EXPR:
16021     case TRUTH_ORIF_EXPR:
16022     case EQ_EXPR:
16023     case NE_EXPR:
16024     case GT_EXPR:
16025     case GE_EXPR:
16026     case LT_EXPR:
16027     case LE_EXPR:
16028       op0 = TREE_OPERAND (node, 0);
16029       op1 = TREE_OPERAND (node, 1);
16030       val = fold_constant_for_init (op0, context);
16031       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16032         return NULL_TREE;
16033       TREE_OPERAND (node, 0) = val;
16034       val = fold_constant_for_init (op1, context);
16035       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16036         return NULL_TREE;
16037       TREE_OPERAND (node, 1) = val;
16038       return patch_binop (node, op0, op1);
16039
16040     case UNARY_PLUS_EXPR:
16041     case NEGATE_EXPR:
16042     case TRUTH_NOT_EXPR:
16043     case BIT_NOT_EXPR:
16044     case CONVERT_EXPR:
16045       op0 = TREE_OPERAND (node, 0);
16046       val = fold_constant_for_init (op0, context);
16047       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16048         return NULL_TREE;
16049       TREE_OPERAND (node, 0) = val;
16050       val = patch_unaryop (node, op0);
16051       if (! TREE_CONSTANT (val))
16052         return NULL_TREE;
16053       return val;
16054
16055       break;
16056
16057     case COND_EXPR:
16058       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
16059       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16060         return NULL_TREE;
16061       TREE_OPERAND (node, 0) = val;
16062       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
16063       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16064         return NULL_TREE;
16065       TREE_OPERAND (node, 1) = val;
16066       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
16067       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16068         return NULL_TREE;
16069       TREE_OPERAND (node, 2) = val;
16070       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
16071         : TREE_OPERAND (node, 2);
16072
16073     case VAR_DECL:
16074     case FIELD_DECL:
16075       if (! FIELD_FINAL (node)
16076           || DECL_INITIAL (node) == NULL_TREE)
16077         return NULL_TREE;
16078       val = DECL_INITIAL (node);
16079       /* Guard against infinite recursion. */
16080       DECL_INITIAL (node) = NULL_TREE;
16081       val = fold_constant_for_init (val, node);
16082       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
16083         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
16084       DECL_INITIAL (node) = val;
16085       return val;
16086
16087     case EXPR_WITH_FILE_LOCATION:
16088       /* Compare java_complete_tree and resolve_expression_name. */
16089       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
16090           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
16091         {
16092           tree name = EXPR_WFL_NODE (node);
16093           tree decl;
16094           if (PRIMARY_P (node))
16095             return NULL_TREE;
16096           else if (! QUALIFIED_P (name))
16097             {
16098               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
16099               if (decl == NULL_TREE
16100                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16101                 return NULL_TREE;
16102               return fold_constant_for_init (decl, decl);
16103             }
16104           else
16105             {
16106               /* Install the proper context for the field resolution.
16107                  The prior context is restored once the name is
16108                  properly qualified. */
16109               tree saved_current_class = current_class;
16110               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
16111               current_class = DECL_CONTEXT (context);
16112               qualify_ambiguous_name (node);
16113               current_class = saved_current_class;
16114               if (resolve_field_access (node, &decl, NULL)
16115                   && decl != NULL_TREE)
16116                 return fold_constant_for_init (decl, decl);
16117               return NULL_TREE;
16118             }
16119         }
16120       else
16121         {
16122           op0 = TREE_OPERAND (node, 0);
16123           val = fold_constant_for_init (op0, context);
16124           if (val == NULL_TREE || ! TREE_CONSTANT (val))
16125             return NULL_TREE;
16126           TREE_OPERAND (node, 0) = val;
16127           return val;
16128         }
16129
16130 #ifdef USE_COMPONENT_REF
16131     case IDENTIFIER:
16132     case COMPONENT_REF:
16133       ?;
16134 #endif
16135
16136     default:
16137       return NULL_TREE;
16138     }
16139 }
16140
16141 #ifdef USE_COMPONENT_REF
16142 /* Context is 'T' for TypeName, 'P' for PackageName,
16143    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16144
16145 tree
16146 resolve_simple_name (tree name, int context)
16147 {
16148 }
16149
16150 tree
16151 resolve_qualified_name (tree name, int context)
16152 {
16153 }
16154 #endif
16155
16156 void
16157 init_src_parse (void)
16158 {
16159   /* Sanity check; we've been bit by this before.  */
16160   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16161     abort ();
16162 }
16163
16164 \f
16165
16166 /* This section deals with the functions that are called when tables
16167    recording class initialization information are traversed.  */
16168
16169 /* Attach to PTR (a block) the declaration found in ENTRY. */
16170
16171 static int
16172 attach_init_test_initialization_flags (void **entry, void *ptr)
16173 {
16174   tree block = (tree)ptr;
16175   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16176
16177   if (block != error_mark_node)
16178     {
16179       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16180       BLOCK_EXPR_DECLS (block) = ite->value;
16181     }
16182   return true;
16183 }
16184
16185 /* This function is called for each class that is known definitely
16186    initialized when a given static method was called. This function
16187    augments a compound expression (INFO) storing all assignment to
16188    initialized static class flags if a flag already existed, otherwise
16189    a new one is created.  */
16190
16191 static int
16192 emit_test_initialization (void **entry_p, void *info)
16193 {
16194   tree l = (tree) info;
16195   tree decl, init;
16196   tree key = (tree) *entry_p;
16197   tree *ite;
16198   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16199
16200   /* If we haven't found a flag and we're dealing with self registered
16201      with current_function_decl, then don't do anything. Self is
16202      always added as definitely initialized but this information is
16203      valid only if used outside the current function. */
16204   if (current_function_decl == TREE_PURPOSE (l)
16205       && java_treetreehash_find (cf_ht, key) == NULL)
16206     return true;
16207
16208   ite = java_treetreehash_new (cf_ht, key);
16209
16210   /* If we don't have a variable, create one and install it. */
16211   if (*ite == NULL)
16212     {
16213       tree block;
16214
16215       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16216       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16217       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16218       DECL_CONTEXT (decl) = current_function_decl;
16219       DECL_INITIAL (decl) = boolean_true_node;
16220       /* Don't emit any symbolic debugging info for this decl.  */
16221       DECL_IGNORED_P (decl) = 1;
16222
16223       /* The trick is to find the right context for it. */
16224       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16225       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16226       BLOCK_EXPR_DECLS (block) = decl;
16227       *ite = decl;
16228     }
16229   else
16230     decl = *ite;
16231
16232   /* Now simply augment the compound that holds all the assignments
16233      pertaining to this method invocation. */
16234   init = build (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16235   TREE_SIDE_EFFECTS (init) = 1;
16236   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16237   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16238
16239   return true;
16240 }
16241
16242 #include "gt-java-parse.h"
16243 #include "gtype-java.h"