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 void  classitf_redefinition_error (const char *,tree, tree, tree);
  80 static void  variable_redefinition_error (tree, tree, tree, int);
  81 static tree  create_class (int, tree, tree, tree);
  82 static tree  create_interface (int, tree, tree);
  83 static void  end_class_declaration (int);
  84 static tree  find_field (tree, tree);
  85 static tree lookup_field_wrapper (tree, tree);
  86 static int   duplicate_declaration_error_p (tree, tree, tree);
  87 static void  register_fields (int, tree, tree);
  88 static tree parser_qualified_classname (tree);
  89 static int  parser_check_super (tree, tree, tree);
  90 static int  parser_check_super_interface (tree, tree, tree);
  91 static void check_modifiers_consistency (int);
  92 static tree lookup_cl (tree);
  93 static tree lookup_java_method2 (tree, tree, int);
  94 static tree method_header (int, tree, tree, tree);
  95 static void fix_method_argument_names (tree ,tree);
  96 static tree method_declarator (tree, tree);
  97 static void parse_warning_context (tree cl, const char *msg, ...)
  98   ATTRIBUTE_PRINTF_2;
  99 static void issue_warning_error_from_context (tree, const char *msg, va_list)
 100   ATTRIBUTE_PRINTF (2, 0);
 101 static void parse_ctor_invocation_error (void);
 102 static tree parse_jdk1_1_error (const char *);
 103 static void complete_class_report_errors (jdep *);
 104 static int process_imports (void);
 105 static void read_import_dir (tree);
 106 static int find_in_imports_on_demand (tree, tree);
 107 static void find_in_imports (tree, tree);
 108 static void check_inner_class_access (tree, tree, tree);
 109 static int check_pkg_class_access (tree, tree, bool);
 110 static void register_package (tree);
 111 static tree resolve_package (tree, tree *, tree *);
 112 static tree resolve_class (tree, tree, tree, tree);
 113 static void declare_local_variables (int, tree, tree);
 114 static void dump_java_tree (enum tree_dump_index, tree);
 115 static void source_start_java_method (tree);
 116 static void source_end_java_method (void);
 117 static tree find_name_in_single_imports (tree);
 118 static void check_abstract_method_header (tree);
 119 static tree lookup_java_interface_method2 (tree, tree);
 120 static tree resolve_expression_name (tree, tree *);
 121 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
 122 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
 123 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
 124 static int breakdown_qualified (tree *, tree *, tree);
 125 static int in_same_package (tree, tree);
 126 static tree resolve_and_layout (tree, tree);
 127 static tree qualify_and_find (tree, tree, tree);
 128 static tree resolve_no_layout (tree, tree);
 129 static int invocation_mode (tree, int);
 130 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
 131 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
 132 static tree find_most_specific_methods_list (tree);
 133 static int argument_types_convertible (tree, tree);
 134 static tree patch_invoke (tree, tree, tree);
 135 static int maybe_use_access_method (int, tree *, tree *);
 136 static tree lookup_method_invoke (int, tree, tree, tree, tree);
 137 static tree register_incomplete_type (int, tree, tree, tree);
 138 static tree check_inner_circular_reference (tree, tree);
 139 static tree check_circular_reference (tree);
 140 static tree obtain_incomplete_type (tree);
 141 static tree java_complete_lhs (tree);
 142 static tree java_complete_tree (tree);
 143 static tree maybe_generate_pre_expand_clinit (tree);
 144 static int analyze_clinit_body (tree, tree);
 145 static int maybe_yank_clinit (tree);
 146 static void java_complete_expand_method (tree);
 147 static void java_expand_method_bodies (tree);
 148 static int  unresolved_type_p (tree, tree *);
 149 static void create_jdep_list (struct parser_ctxt *);
 150 static tree build_expr_block (tree, tree);
 151 static tree enter_block (void);
 152 static tree exit_block (void);
 153 static tree lookup_name_in_blocks (tree);
 154 static void maybe_absorb_scoping_blocks (void);
 155 static tree build_method_invocation (tree, tree);
 156 static tree build_new_invocation (tree, tree);
 157 static tree build_assignment (int, int, tree, tree);
 158 static tree build_binop (enum tree_code, int, tree, tree);
 159 static tree patch_assignment (tree, tree);
 160 static tree patch_binop (tree, tree, tree);
 161 static tree build_unaryop (int, int, tree);
 162 static tree build_incdec (int, int, tree, int);
 163 static tree patch_unaryop (tree, tree);
 164 static tree build_cast (int, tree, tree);
 165 static tree build_null_of_type (tree);
 166 static tree patch_cast (tree, tree);
 167 static int valid_ref_assignconv_cast_p (tree, tree, int);
 168 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
 169 static int valid_cast_to_p (tree, tree);
 170 static int valid_method_invocation_conversion_p (tree, tree);
 171 static tree try_builtin_assignconv (tree, tree, tree);
 172 static tree try_reference_assignconv (tree, tree);
 173 static tree build_unresolved_array_type (tree);
 174 static int build_type_name_from_array_name (tree, tree *);
 175 static tree build_array_from_name (tree, tree, tree, tree *);
 176 static tree build_array_ref (int, tree, tree);
 177 static tree patch_array_ref (tree);
 178 static tree make_qualified_name (tree, tree, int);
 179 static tree merge_qualified_name (tree, tree);
 180 static tree make_qualified_primary (tree, tree, int);
 181 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
 182 static void qualify_ambiguous_name (tree);
 183 static tree resolve_field_access (tree, tree *, tree *);
 184 static tree build_newarray_node (tree, tree, int);
 185 static tree patch_newarray (tree);
 186 static tree resolve_type_during_patch (tree);
 187 static tree build_this (int);
 188 static tree build_wfl_wrap (tree, int);
 189 static tree build_return (int, tree);
 190 static tree patch_return (tree);
 191 static tree maybe_access_field (tree, tree, tree);
 192 static int complete_function_arguments (tree);
 193 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
 194 static int not_accessible_p (tree, tree, tree, int);
 195 static void check_deprecation (tree, tree);
 196 static int class_in_current_package (tree);
 197 static tree build_if_else_statement (int, tree, tree, tree);
 198 static tree patch_if_else_statement (tree);
 199 static tree add_stmt_to_compound (tree, tree, tree);
 200 static tree add_stmt_to_block (tree, tree, tree);
 201 static tree patch_exit_expr (tree);
 202 static tree build_labeled_block (int, tree);
 203 static tree finish_labeled_statement (tree, tree);
 204 static tree build_bc_statement (int, int, tree);
 205 static tree patch_bc_statement (tree);
 206 static tree patch_loop_statement (tree);
 207 static tree build_new_loop (tree);
 208 static tree build_loop_body (int, tree, int);
 209 static tree finish_loop_body (int, tree, tree, int);
 210 static tree build_debugable_stmt (int, tree);
 211 static tree finish_for_loop (int, tree, tree, tree);
 212 static tree patch_switch_statement (tree);
 213 static tree string_constant_concatenation (tree, tree);
 214 static tree build_string_concatenation (tree, tree);
 215 static tree patch_string_cst (tree);
 216 static tree patch_string (tree);
 217 static tree encapsulate_with_try_catch (int, tree, tree, tree);
 218 static tree build_assertion (int, tree, tree);
 219 static tree build_try_statement (int, tree, tree);
 220 static tree build_try_finally_statement (int, tree, tree);
 221 static tree patch_try_statement (tree);
 222 static tree patch_synchronized_statement (tree, tree);
 223 static tree patch_throw_statement (tree, tree);
 224 static void check_thrown_exceptions (int, tree, tree);
 225 static int check_thrown_exceptions_do (tree);
 226 static void purge_unchecked_exceptions (tree);
 227 static bool ctors_unchecked_throws_clause_p (tree);
 228 static void check_concrete_throws_clauses (tree, tree, tree, tree);
 229 static void check_throws_clauses (tree, tree, tree);
 230 static void finish_method_declaration (tree);
 231 static tree build_super_invocation (tree);
 232 static int verify_constructor_circularity (tree, tree);
 233 static char *constructor_circularity_msg (tree, tree);
 234 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
 235 static const char *get_printable_method_name (tree);
 236 static tree patch_conditional_expr (tree, tree, tree);
 237 static tree generate_finit (tree);
 238 static tree generate_instinit (tree);
 239 static tree build_instinit_invocation (tree);
 240 static void fix_constructors (tree);
 241 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
 242 static tree craft_constructor (tree, tree);
 243 static int verify_constructor_super (tree);
 244 static tree create_artificial_method (tree, int, tree, tree, tree);
 245 static void start_artificial_method_body (tree);
 246 static void end_artificial_method_body (tree);
 247 static int check_method_redefinition (tree, tree);
 248 static int check_method_types_complete (tree);
 249 static bool hack_is_accessible_p (tree, tree);
 250 static void java_check_regular_methods (tree);
 251 static void check_interface_throws_clauses (tree, tree);
 252 static void java_check_abstract_methods (tree);
 253 static void unreachable_stmt_error (tree);
 254 static int not_accessible_field_error (tree, tree);
 255 static tree find_expr_with_wfl (tree);
 256 static void missing_return_error (tree);
 257 static tree build_new_array_init (int, tree);
 258 static tree patch_new_array_init (tree, tree);
 259 static tree maybe_build_array_element_wfl (tree);
 260 static int array_constructor_check_entry (tree, tree);
 261 static const char *purify_type_name (const char *);
 262 static tree fold_constant_for_init (tree, tree);
 263 static tree strip_out_static_field_access_decl (tree);
 264 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
 265 static void static_ref_err (tree, tree, tree);
 266 static void parser_add_interface (tree, tree, tree);
 267 static void add_superinterfaces (tree, tree);
 268 static tree jdep_resolve_class (jdep *);
 269 static int note_possible_classname (const char *, int);
 270 static void java_complete_expand_classes (void);
 271 static void java_complete_expand_class (tree);
 272 static void java_complete_expand_methods (tree);
 273 static tree cut_identifier_in_qualified (tree);
 274 static tree java_stabilize_reference (tree);
 275 static tree do_unary_numeric_promotion (tree);
 276 static char * operator_string (tree);
 277 static tree do_merge_string_cste (tree, const char *, int, int);
 278 static tree merge_string_cste (tree, tree, int);
 279 static tree java_refold (tree);
 280 static int java_decl_equiv (tree, tree);
 281 static int binop_compound_p (enum tree_code);
 282 static tree search_loop (tree);
 283 static int labeled_block_contains_loop_p (tree, tree);
 284 static int check_abstract_method_definitions (int, tree, tree);
 285 static void java_check_abstract_method_definitions (tree);
 286 static void java_debug_context_do (int);
 287 static void java_parser_context_push_initialized_field (void);
 288 static void java_parser_context_pop_initialized_field (void);
 289 static tree reorder_static_initialized (tree);
 290 static void java_parser_context_suspend (void);
 291 static void java_parser_context_resume (void);
 292 static int pop_current_osb (struct parser_ctxt *);
 293
 294 /* JDK 1.1 work. FIXME */
 295
 296 static tree maybe_make_nested_class_name (tree);
 297 static int make_nested_class_name (tree);
 298 static void set_nested_class_simple_name_value (tree, int);
 299 static void link_nested_class_to_enclosing (void);
 300 static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
 301 static tree find_as_inner_class (tree, tree, tree);
 302 static tree find_as_inner_class_do (tree, tree);
 303 static int check_inner_class_redefinition (tree, tree);
 304
 305 static tree build_thisn_assign (void);
 306 static tree build_current_thisn (tree);
 307 static tree build_access_to_thisn (tree, tree, int);
 308 static tree maybe_build_thisn_access_method (tree);
 309
 310 static tree build_outer_field_access (tree, tree);
 311 static tree build_outer_field_access_methods (tree);
 312 static tree build_outer_field_access_expr (int, tree, tree,
 313                                                   tree, tree);
 314 static tree build_outer_method_access_method (tree);
 315 static tree build_new_access_id (void);
 316 static tree build_outer_field_access_method (tree, tree, tree,
 317                                                     tree, tree);
 318
 319 static int outer_field_access_p (tree, tree);
 320 static int outer_field_expanded_access_p (tree, tree *,
 321                                                  tree *, tree *);
 322 static tree outer_field_access_fix (tree, tree, tree);
 323 static tree build_incomplete_class_ref (int, tree);
 324 static tree patch_incomplete_class_ref (tree);
 325 static tree create_anonymous_class (int, tree);
 326 static void patch_anonymous_class (tree, tree, tree);
 327 static void add_inner_class_fields (tree, tree);
 328
 329 static tree build_dot_class_method (tree);
 330 static tree build_dot_class_method_invocation (tree, tree);
 331 static void create_new_parser_context (int);
 332 static tree maybe_build_class_init_for_field (tree, tree);
 333
 334 static int attach_init_test_initialization_flags (void **, void *);
 335 static int emit_test_initialization (void **, void *);
 336
 337 static char *string_convert_int_cst (tree);
 338
 339 /* Number of error found so far. */
 340 int java_error_count;
 341 /* Number of warning found so far. */
 342 int java_warning_count;
 343 /* Tell when not to fold, when doing xrefs */
 344 int do_not_fold;
 345 /* Cyclic inheritance report, as it can be set by layout_class */
 346 const char *cyclic_inheritance_report;
 347
 348 /* The current parser context */
 349 struct parser_ctxt *ctxp;
 350
 351 /* List of things that were analyzed for which code will be generated */
 352 struct parser_ctxt *ctxp_for_generation = NULL;
 353
 354 /* binop_lookup maps token to tree_code. It is used where binary
 355    operations are involved and required by the parser. RDIV_EXPR
 356    covers both integral/floating point division. The code is changed
 357    once the type of both operator is worked out.  */
 358
 359 static const enum tree_code binop_lookup[19] =
 360   {
 361     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
 362     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
 363     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
 364     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
 365     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
 366    };
 367 #define BINOP_LOOKUP(VALUE)                                             \
 368   binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
 369
 370 /* This is the end index for binary operators that can also be used
 371    in compound assignments. */
 372 #define BINOP_COMPOUND_CANDIDATES 11
 373
 374 /* The "$L" identifier we use to create labels.  */
 375 static GTY(()) tree label_id;
 376
 377 /* The "StringBuffer" identifier used for the String `+' operator. */
 378 static GTY(()) tree wfl_string_buffer;
 379
 380 /* The "append" identifier used for String `+' operator.  */
 381 static GTY(()) tree wfl_append;
 382
 383 /* The "toString" identifier used for String `+' operator. */
 384 static GTY(()) tree wfl_to_string;
 385
 386 /* The "java.lang" import qualified name.  */
 387 static GTY(()) tree java_lang_id;
 388
 389 /* The generated `inst$' identifier used for generated enclosing
 390    instance/field access functions.  */
 391 static GTY(()) tree inst_id;
 392
 393 /* Context and flag for static blocks */
 394 static GTY(()) tree current_static_block;
 395
 396 /* The generated `write_parm_value$' identifier.  */
 397 static GTY(()) tree wpv_id;
 398
 399 /* The list of all packages we've seen so far */
 400 static GTY(()) tree package_list;
 401
 402 /* Hold THIS for the scope of the current method decl.  */
 403 static GTY(()) tree current_this;
 404
 405 /* Hold a list of catch clauses list. The first element of this list is
 406    the list of the catch clauses of the currently analyzed try block. */
 407 static GTY(()) tree currently_caught_type_list;
 408
 409 /* This holds a linked list of all the case labels for the current
 410    switch statement.  It is only used when checking to see if there
 411    are duplicate labels.  FIXME: probably this should just be attached
 412    to the switch itself; then it could be referenced via
 413    `ctxp->current_loop'.  */
 414 static GTY(()) tree case_label_list;
 415
 416 /* Anonymous class counter. Will be reset to 1 every time a non
 417    anonymous class gets created. */
 418 static int anonymous_class_counter = 1;
 419
 420 static GTY(()) tree src_parse_roots[1];
 421
 422 /* All classes seen from source code */
 423 #define gclass_list src_parse_roots[0]
 424
 425 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
 426    line and point it out.  */
 427 /* Should point out the one that don't fit. ASCII/unicode, going
 428    backward. FIXME */
 429
 430 #define check_modifiers(__message, __value, __mask) do {        \
 431   if ((__value) & ~(__mask))                                    \
 432     {                                                           \
 433       size_t i, remainder = (__value) & ~(__mask);              \
 434       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)     \
 435         if ((1 << i) & remainder)                               \
 436           parse_error_context (ctxp->modifier_ctx [i], (__message), \
 437                                java_accstring_lookup (1 << i)); \
 438     }                                                           \
 439 } while (0)
 440
 441 %}
 442
 443 %union {
 444   tree node;
 445   int sub_token;
 446   struct {
 447     int token;
 448     int location;
 449   } operator;
 450   int value;
 451 }
 452
 453 %{
 454 #include "lex.c"
 455 %}
 456
 457 %pure_parser
 458
 459 /* Things defined here have to match the order of what's in the
 460    binop_lookup table.  */
 461
 462 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
 463 %token   LS_TK           SRS_TK          ZRS_TK
 464 %token   AND_TK          XOR_TK          OR_TK
 465 %token   BOOL_AND_TK BOOL_OR_TK
 466 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
 467
 468 /* This maps to the same binop_lookup entry than the token above */
 469
 470 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
 471 %token   REM_ASSIGN_TK
 472 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 473 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
 474
 475
 476 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
 477
 478 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
 479 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
 480 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
 481 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
 482 %token   MODIFIER_TK
 483
 484 /* Keep those two in order, too */
 485 %token   DECR_TK INCR_TK
 486
 487 /* From now one, things can be in any order */
 488
 489 %token   DEFAULT_TK      IF_TK              THROW_TK
 490 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
 491 %token   THROWS_TK       BREAK_TK           IMPORT_TK
 492 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
 493 %token   VOID_TK         CATCH_TK           INTERFACE_TK
 494 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
 495 %token   SUPER_TK        WHILE_TK           CLASS_TK
 496 %token   SWITCH_TK       CONST_TK           TRY_TK
 497 %token   FOR_TK          NEW_TK             CONTINUE_TK
 498 %token   GOTO_TK         PACKAGE_TK         THIS_TK
 499 %token   ASSERT_TK
 500
 501 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
 502 %token   CHAR_TK         INTEGRAL_TK
 503
 504 %token   FLOAT_TK        DOUBLE_TK          FP_TK
 505
 506 %token   ID_TK
 507
 508 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
 509
 510 %token   ASSIGN_ANY_TK   ASSIGN_TK
 511 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
 512
 513 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
 514 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
 515
 516 %type    <value>        modifiers MODIFIER_TK final synchronized
 517
 518 %type    <node>         super ID_TK identifier
 519 %type    <node>         name simple_name qualified_name
 520 %type    <node>         type_declaration compilation_unit
 521                         field_declaration method_declaration extends_interfaces
 522                         interfaces interface_type_list
 523                         import_declarations package_declaration
 524                         type_declarations interface_body
 525                         interface_member_declaration constant_declaration
 526                         interface_member_declarations interface_type
 527                         abstract_method_declaration
 528 %type    <node>         class_body_declaration class_member_declaration
 529                         static_initializer constructor_declaration block
 530 %type    <node>         class_body_declarations constructor_header
 531 %type    <node>         class_or_interface_type class_type class_type_list
 532                         constructor_declarator explicit_constructor_invocation
 533 %type    <node>         dim_expr dim_exprs this_or_super throws
 534
 535 %type    <node>         variable_declarator_id variable_declarator
 536                         variable_declarators variable_initializer
 537                         variable_initializers constructor_body
 538                         array_initializer
 539
 540 %type    <node>         class_body block_end constructor_block_end
 541 %type    <node>         statement statement_without_trailing_substatement
 542                         labeled_statement if_then_statement label_decl
 543                         if_then_else_statement while_statement for_statement
 544                         statement_nsi labeled_statement_nsi do_statement
 545                         if_then_else_statement_nsi while_statement_nsi
 546                         for_statement_nsi statement_expression_list for_init
 547                         for_update statement_expression expression_statement
 548                         primary_no_new_array expression primary
 549                         array_creation_expression array_type
 550                         class_instance_creation_expression field_access
 551                         method_invocation array_access something_dot_new
 552                         argument_list postfix_expression while_expression
 553                         post_increment_expression post_decrement_expression
 554                         unary_expression_not_plus_minus unary_expression
 555                         pre_increment_expression pre_decrement_expression
 556                         cast_expression
 557                         multiplicative_expression additive_expression
 558                         shift_expression relational_expression
 559                         equality_expression and_expression
 560                         exclusive_or_expression inclusive_or_expression
 561                         conditional_and_expression conditional_or_expression
 562                         conditional_expression assignment_expression
 563                         left_hand_side assignment for_header for_begin
 564                         constant_expression do_statement_begin empty_statement
 565                         switch_statement synchronized_statement throw_statement
 566                         try_statement assert_statement
 567                         switch_expression switch_block
 568                         catches catch_clause catch_clause_parameter finally
 569                         anonymous_class_creation trap_overflow_corner_case
 570 %type    <node>         return_statement break_statement continue_statement
 571
 572 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
 573 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
 574 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 575 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
 576 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
 577 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
 578 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
 579 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
 580 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
 581 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
 582 %type    <operator>     THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
 583 %type    <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
 584 %type    <operator>     NEW_TK ASSERT_TK
 585
 586 %type    <node>         method_body
 587
 588 %type    <node>         literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
 589                         STRING_LIT_TK NULL_TK VOID_TK
 590
 591 %type    <node>         IF_TK WHILE_TK FOR_TK
 592
 593 %type    <node>         formal_parameter_list formal_parameter
 594                         method_declarator method_header
 595
 596 %type    <node>         primitive_type reference_type type
 597                         BOOLEAN_TK INTEGRAL_TK FP_TK
 598
 599 /* Added or modified JDK 1.1 rule types  */
 600 %type    <node>         type_literals
 601
 602 %%
 603 /* 19.2 Production from 2.3: The Syntactic Grammar  */
 604 goal:  compilation_unit
 605                 {}
 606 ;
 607
 608 /* 19.3 Productions from 3: Lexical structure  */
 609 literal:
 610         INT_LIT_TK
 611 |       FP_LIT_TK
 612 |       BOOL_LIT_TK
 613 |       CHAR_LIT_TK
 614 |       STRING_LIT_TK
 615 |       NULL_TK
 616 ;
 617
 618 /* 19.4 Productions from 4: Types, Values and Variables  */
 619 type:
 620         primitive_type
 621 |       reference_type
 622 ;
 623
 624 primitive_type:
 625         INTEGRAL_TK
 626 |       FP_TK
 627 |       BOOLEAN_TK
 628 ;
 629
 630 reference_type:
 631         class_or_interface_type
 632 |       array_type
 633 ;
 634
 635 class_or_interface_type:
 636         name
 637 ;
 638
 639 class_type:
 640         class_or_interface_type /* Default rule */
 641 ;
 642
 643 interface_type:
 644          class_or_interface_type
 645 ;
 646
 647 array_type:
 648         primitive_type dims
 649                 {
 650                   int osb = pop_current_osb (ctxp);
 651                   tree t = build_java_array_type (($1), -1);
 652                   while (--osb)
 653                     t = build_unresolved_array_type (t);
 654                   $$ = t;
 655                 }
 656 |       name dims
 657                 {
 658                   int osb = pop_current_osb (ctxp);
 659                   tree t = $1;
 660                   while (osb--)
 661                     t = build_unresolved_array_type (t);
 662                   $$ = t;
 663                 }
 664 ;
 665
 666 /* 19.5 Productions from 6: Names  */
 667 name:
 668         simple_name             /* Default rule */
 669 |       qualified_name          /* Default rule */
 670 ;
 671
 672 simple_name:
 673         identifier              /* Default rule */
 674 ;
 675
 676 qualified_name:
 677         name DOT_TK identifier
 678                 { $$ = make_qualified_name ($1, $3, $2.location); }
 679 ;
 680
 681 identifier:
 682         ID_TK
 683 ;
 684
 685 /* 19.6: Production from 7: Packages  */
 686 compilation_unit:
 687                 {$$ = NULL;}
 688 |       package_declaration
 689 |       import_declarations
 690 |       type_declarations
 691 |       package_declaration import_declarations
 692 |       package_declaration type_declarations
 693 |       import_declarations type_declarations
 694 |       package_declaration import_declarations type_declarations
 695 ;
 696
 697 import_declarations:
 698         import_declaration
 699                 {
 700                   $$ = NULL;
 701                 }
 702 |       import_declarations import_declaration
 703                 {
 704                   $$ = NULL;
 705                 }
 706 ;
 707
 708 type_declarations:
 709         type_declaration
 710 |       type_declarations type_declaration
 711 ;
 712
 713 package_declaration:
 714         PACKAGE_TK name SC_TK
 715                 {
 716                   ctxp->package = EXPR_WFL_NODE ($2);
 717                   register_package (ctxp->package);
 718                 }
 719 |       PACKAGE_TK error
 720                 {yyerror ("Missing name"); RECOVER;}
 721 |       PACKAGE_TK name error
 722                 {yyerror ("';' expected"); RECOVER;}
 723 ;
 724
 725 import_declaration:
 726         single_type_import_declaration
 727 |       type_import_on_demand_declaration
 728 ;
 729
 730 single_type_import_declaration:
 731         IMPORT_TK name SC_TK
 732                 {
 733                   tree name = EXPR_WFL_NODE ($2), last_name;
 734                   int   i = IDENTIFIER_LENGTH (name)-1;
 735                   const char *last = &IDENTIFIER_POINTER (name)[i];
 736                   while (last != IDENTIFIER_POINTER (name))
 737                     {
 738                       if (last [0] == '.')
 739                         break;
 740                       last--;
 741                     }
 742                   last_name = get_identifier (++last);
 743                   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
 744                     {
 745                       tree err = find_name_in_single_imports (last_name);
 746                       if (err && err != name)
 747                         parse_error_context
 748                           ($2, "Ambiguous class: `%s' and `%s'",
 749                            IDENTIFIER_POINTER (name),
 750                            IDENTIFIER_POINTER (err));
 751                       else
 752                         REGISTER_IMPORT ($2, last_name);
 753                     }
 754                   else
 755                     REGISTER_IMPORT ($2, last_name);
 756                 }
 757 |       IMPORT_TK error
 758                 {yyerror ("Missing name"); RECOVER;}
 759 |       IMPORT_TK name error
 760                 {yyerror ("';' expected"); RECOVER;}
 761 ;
 762
 763 type_import_on_demand_declaration:
 764         IMPORT_TK name DOT_TK MULT_TK SC_TK
 765                 {
 766                   tree name = EXPR_WFL_NODE ($2);
 767                   tree it;
 768                   /* Search for duplicates. */
 769                   for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
 770                     if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
 771                       break;
 772                   /* Don't import the same thing more than once, just ignore
 773                      duplicates (7.5.2) */
 774                   if (! it)
 775                     {
 776                       read_import_dir ($2);
 777                       ctxp->import_demand_list =
 778                         chainon (ctxp->import_demand_list,
 779                                  build_tree_list ($2, NULL_TREE));
 780                     }
 781                 }
 782 |       IMPORT_TK name DOT_TK error
 783                 {yyerror ("'*' expected"); RECOVER;}
 784 |       IMPORT_TK name DOT_TK MULT_TK error
 785                 {yyerror ("';' expected"); RECOVER;}
 786 ;
 787
 788 type_declaration:
 789         class_declaration
 790                 { end_class_declaration (0); }
 791 |       interface_declaration
 792                 { end_class_declaration (0); }
 793 |       empty_statement
 794 |       error
 795                 {
 796                   YYERROR_NOW;
 797                   yyerror ("Class or interface declaration expected");
 798                 }
 799 ;
 800
 801 /* 19.7 Shortened from the original:
 802    modifiers: modifier | modifiers modifier
 803    modifier: any of public...  */
 804 modifiers:
 805         MODIFIER_TK
 806                 {
 807                   $$ = (1 << $1);
 808                 }
 809 |       modifiers MODIFIER_TK
 810                 {
 811                   int acc = (1 << $2);
 812                   if ($$ & acc)
 813                     parse_error_context
 814                       (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
 815                        java_accstring_lookup (acc));
 816                   else
 817                     {
 818                       $$ |= acc;
 819                     }
 820                 }
 821 ;
 822
 823 /* 19.8.1 Production from $8.1: Class Declaration */
 824 class_declaration:
 825         modifiers CLASS_TK identifier super interfaces
 826                 { create_class ($1, $3, $4, $5); }
 827         class_body
 828                 {;}
 829 |       CLASS_TK identifier super interfaces
 830                 { create_class (0, $2, $3, $4); }
 831         class_body
 832                 {;}
 833 |       modifiers CLASS_TK error
 834                 { yyerror ("Missing class name"); RECOVER; }
 835 |       CLASS_TK error
 836                 { yyerror ("Missing class name"); RECOVER; }
 837 |       CLASS_TK identifier error
 838                 {
 839                   if (!ctxp->class_err) yyerror ("'{' expected");
 840                   DRECOVER(class1);
 841                 }
 842 |       modifiers CLASS_TK identifier error
 843                 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
 844 ;
 845
 846 super:
 847                 { $$ = NULL; }
 848 |       EXTENDS_TK class_type
 849                 { $$ = $2; }
 850 |       EXTENDS_TK class_type error
 851                 {yyerror ("'{' expected"); ctxp->class_err=1;}
 852 |       EXTENDS_TK error
 853                 {yyerror ("Missing super class name"); ctxp->class_err=1;}
 854 ;
 855
 856 interfaces:
 857                 { $$ = NULL_TREE; }
 858 |       IMPLEMENTS_TK interface_type_list
 859                 { $$ = $2; }
 860 |       IMPLEMENTS_TK error
 861                 {
 862                   ctxp->class_err=1;
 863                   yyerror ("Missing interface name");
 864                 }
 865 ;
 866
 867 interface_type_list:
 868         interface_type
 869                 {
 870                   ctxp->interface_number = 1;
 871                   $$ = build_tree_list ($1, NULL_TREE);
 872                 }
 873 |       interface_type_list C_TK interface_type
 874                 {
 875                   ctxp->interface_number++;
 876                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
 877                 }
 878 |       interface_type_list C_TK error
 879                 {yyerror ("Missing interface name"); RECOVER;}
 880 ;
 881
 882 class_body:
 883         OCB_TK CCB_TK
 884                 {
 885                   /* Store the location of the `}' when doing xrefs */
 886                   if (flag_emit_xref)
 887                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 888                       EXPR_WFL_ADD_COL ($2.location, 1);
 889                   $$ = GET_CPC ();
 890                 }
 891 |       OCB_TK class_body_declarations CCB_TK
 892                 {
 893                   /* Store the location of the `}' when doing xrefs */
 894                   if (flag_emit_xref)
 895                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 896                       EXPR_WFL_ADD_COL ($3.location, 1);
 897                   $$ = GET_CPC ();
 898                 }
 899 ;
 900
 901 class_body_declarations:
 902         class_body_declaration
 903 |       class_body_declarations class_body_declaration
 904 ;
 905
 906 class_body_declaration:
 907         class_member_declaration
 908 |       static_initializer
 909 |       constructor_declaration
 910 |       block                   /* Added, JDK1.1, instance initializer */
 911                 {
 912                   if ($1 != empty_stmt_node)
 913                     {
 914                       TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
 915                       SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
 916                     }
 917                 }
 918 ;
 919
 920 class_member_declaration:
 921         field_declaration
 922 |       method_declaration
 923 |       class_declaration       /* Added, JDK1.1 inner classes */
 924                 { end_class_declaration (1); }
 925 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
 926                 { end_class_declaration (1); }
 927 |       empty_statement
 928 ;
 929
 930 /* 19.8.2 Productions from 8.3: Field Declarations  */
 931 field_declaration:
 932         type variable_declarators SC_TK
 933                 { register_fields (0, $1, $2); }
 934 |       modifiers type variable_declarators SC_TK
 935                 {
 936                   check_modifiers
 937                     ("Illegal modifier `%s' for field declaration",
 938                      $1, FIELD_MODIFIERS);
 939                   check_modifiers_consistency ($1);
 940                   register_fields ($1, $2, $3);
 941                 }
 942 ;
 943
 944 variable_declarators:
 945         /* Should we use build_decl_list () instead ? FIXME */
 946         variable_declarator     /* Default rule */
 947 |       variable_declarators C_TK variable_declarator
 948                 { $$ = chainon ($1, $3); }
 949 |       variable_declarators C_TK error
 950                 {yyerror ("Missing term"); RECOVER;}
 951 ;
 952
 953 variable_declarator:
 954         variable_declarator_id
 955                 { $$ = build_tree_list ($1, NULL_TREE); }
 956 |       variable_declarator_id ASSIGN_TK variable_initializer
 957                 {
 958                   if (java_error_count)
 959                     $3 = NULL_TREE;
 960                   $$ = build_tree_list
 961                     ($1, build_assignment ($2.token, $2.location, $1, $3));
 962                 }
 963 |       variable_declarator_id ASSIGN_TK error
 964                 {
 965                   yyerror ("Missing variable initializer");
 966                   $$ = build_tree_list ($1, NULL_TREE);
 967                   RECOVER;
 968                 }
 969 |       variable_declarator_id ASSIGN_TK variable_initializer error
 970                 {
 971                   yyerror ("';' expected");
 972                   $$ = build_tree_list ($1, NULL_TREE);
 973                   RECOVER;
 974                 }
 975 ;
 976
 977 variable_declarator_id:
 978         identifier
 979 |       variable_declarator_id OSB_TK CSB_TK
 980                 { $$ = build_unresolved_array_type ($1); }
 981 |       identifier error
 982                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
 983 |       variable_declarator_id OSB_TK error
 984                 {
 985                   yyerror ("']' expected");
 986                   DRECOVER(vdi);
 987                 }
 988 |       variable_declarator_id CSB_TK error
 989                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
 990 ;
 991
 992 variable_initializer:
 993         expression
 994 |       array_initializer
 995 ;
 996
 997 /* 19.8.3 Productions from 8.4: Method Declarations  */
 998 method_declaration:
 999         method_header
1000                 {
1001                   current_function_decl = $1;
1002                   if (current_function_decl
1003                       && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1004                     source_start_java_method (current_function_decl);
1005                   else
1006                     current_function_decl = NULL_TREE;
1007                 }
1008         method_body
1009                 { finish_method_declaration ($3); }
1010 |       method_header error
1011                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1012 ;
1013
1014 method_header:
1015         type method_declarator throws
1016                 { $$ = method_header (0, $1, $2, $3); }
1017 |       VOID_TK method_declarator throws
1018                 { $$ = method_header (0, void_type_node, $2, $3); }
1019 |       modifiers type method_declarator throws
1020                 { $$ = method_header ($1, $2, $3, $4); }
1021 |       modifiers VOID_TK method_declarator throws
1022                 { $$ = method_header ($1, void_type_node, $3, $4); }
1023 |       type error
1024                 {
1025                   yyerror ("Invalid method declaration, method name required");
1026                   RECOVER;
1027                 }
1028 |       modifiers type error
1029                 {
1030                   yyerror ("Identifier expected");
1031                   RECOVER;
1032                 }
1033 |       VOID_TK error
1034                 {
1035                   yyerror ("Identifier expected");
1036                   RECOVER;
1037                 }
1038 |       modifiers VOID_TK error
1039                 {
1040                   yyerror ("Identifier expected");
1041                   RECOVER;
1042                 }
1043 |       modifiers error
1044                 {
1045                   yyerror ("Invalid method declaration, return type required");
1046                   RECOVER;
1047                 }
1048 ;
1049
1050 method_declarator:
1051         identifier OP_TK CP_TK
1052                 {
1053                   ctxp->formal_parameter_number = 0;
1054                   $$ = method_declarator ($1, NULL_TREE);
1055                 }
1056 |       identifier OP_TK formal_parameter_list CP_TK
1057                 { $$ = method_declarator ($1, $3); }
1058 |       method_declarator OSB_TK CSB_TK
1059                 {
1060                   EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1061                   TREE_PURPOSE ($1) =
1062                     build_unresolved_array_type (TREE_PURPOSE ($1));
1063                   parse_warning_context
1064                     (wfl_operator,
1065                      "Discouraged form of returned type specification");
1066                 }
1067 |       identifier OP_TK error
1068                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1069 |       method_declarator OSB_TK error
1070                 {yyerror ("']' expected"); RECOVER;}
1071 ;
1072
1073 formal_parameter_list:
1074         formal_parameter
1075                 {
1076                   ctxp->formal_parameter_number = 1;
1077                 }
1078 |       formal_parameter_list C_TK formal_parameter
1079                 {
1080                   ctxp->formal_parameter_number += 1;
1081                   $$ = chainon ($1, $3);
1082                 }
1083 |       formal_parameter_list C_TK error
1084                 { yyerror ("Missing formal parameter term"); RECOVER; }
1085 ;
1086
1087 formal_parameter:
1088         type variable_declarator_id
1089                 {
1090                   $$ = build_tree_list ($2, $1);
1091                 }
1092 |       final type variable_declarator_id /* Added, JDK1.1 final parms */
1093                 {
1094                   $$ = build_tree_list ($3, $2);
1095                   ARG_FINAL_P ($$) = 1;
1096                 }
1097 |       type error
1098                 {
1099                   yyerror ("Missing identifier"); RECOVER;
1100                   $$ = NULL_TREE;
1101                 }
1102 |       final type error
1103                 {
1104                   yyerror ("Missing identifier"); RECOVER;
1105                   $$ = NULL_TREE;
1106                 }
1107 ;
1108
1109 final:
1110         modifiers
1111                 {
1112                   check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1113                                    $1, ACC_FINAL);
1114                   if ($1 != ACC_FINAL)
1115                     MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1116                 }
1117 ;
1118
1119 throws:
1120                 { $$ = NULL_TREE; }
1121 |       THROWS_TK class_type_list
1122                 { $$ = $2; }
1123 |       THROWS_TK error
1124                 {yyerror ("Missing class type term"); RECOVER;}
1125 ;
1126
1127 class_type_list:
1128         class_type
1129                 { $$ = build_tree_list ($1, $1); }
1130 |       class_type_list C_TK class_type
1131                 { $$ = tree_cons ($3, $3, $1); }
1132 |       class_type_list C_TK error
1133                 {yyerror ("Missing class type term"); RECOVER;}
1134 ;
1135
1136 method_body:
1137         block
1138 |       SC_TK { $$ = NULL_TREE; }
1139 ;
1140
1141 /* 19.8.4 Productions from 8.5: Static Initializers  */
1142 static_initializer:
1143         static block
1144                 {
1145                   TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1146                   SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1147                   current_static_block = NULL_TREE;
1148                 }
1149 ;
1150
1151 static:                         /* Test lval.sub_token here */
1152         modifiers
1153                 {
1154                   check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1155                   /* Can't have a static initializer in an innerclass */
1156                   if ($1 | ACC_STATIC &&
1157                       GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1158                     parse_error_context
1159                       (MODIFIER_WFL (STATIC_TK),
1160                        "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1161                        IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1162                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1163                 }
1164 ;
1165
1166 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1167 constructor_declaration:
1168         constructor_header
1169                 {
1170                   current_function_decl = $1;
1171                   source_start_java_method (current_function_decl);
1172                 }
1173         constructor_body
1174                 { finish_method_declaration ($3); }
1175 ;
1176
1177 constructor_header:
1178         constructor_declarator throws
1179                 { $$ = method_header (0, NULL_TREE, $1, $2); }
1180 |       modifiers constructor_declarator throws
1181                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1182 ;
1183
1184 constructor_declarator:
1185         simple_name OP_TK CP_TK
1186                 {
1187                   ctxp->formal_parameter_number = 0;
1188                   $$ = method_declarator ($1, NULL_TREE);
1189                 }
1190 |       simple_name OP_TK formal_parameter_list CP_TK
1191                 { $$ = method_declarator ($1, $3); }
1192 ;
1193
1194 constructor_body:
1195         /* Unlike regular method, we always need a complete (empty)
1196            body so we can safely perform all the required code
1197            addition (super invocation and field initialization) */
1198         block_begin constructor_block_end
1199                 {
1200                   BLOCK_EXPR_BODY ($2) = empty_stmt_node;
1201                   $$ = $2;
1202                 }
1203 |       block_begin explicit_constructor_invocation constructor_block_end
1204                 { $$ = $3; }
1205 |       block_begin block_statements constructor_block_end
1206                 { $$ = $3; }
1207 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1208                 { $$ = $4; }
1209 ;
1210
1211 constructor_block_end:
1212         block_end
1213 ;
1214
1215 /* Error recovery for that rule moved down expression_statement: rule.  */
1216 explicit_constructor_invocation:
1217         this_or_super OP_TK CP_TK SC_TK
1218                 {
1219                   $$ = build_method_invocation ($1, NULL_TREE);
1220                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1221                   $$ = java_method_add_stmt (current_function_decl, $$);
1222                 }
1223 |       this_or_super OP_TK argument_list CP_TK SC_TK
1224                 {
1225                   $$ = build_method_invocation ($1, $3);
1226                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1227                   $$ = java_method_add_stmt (current_function_decl, $$);
1228                 }
1229         /* Added, JDK1.1 inner classes. Modified because the rule
1230            'primary' couldn't work.  */
1231 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1232                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1233 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1234                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1235 ;
1236
1237 this_or_super:                  /* Added, simplifies error diagnostics */
1238         THIS_TK
1239                 {
1240                   tree wfl = build_wfl_node (this_identifier_node);
1241                   EXPR_WFL_LINECOL (wfl) = $1.location;
1242                   $$ = wfl;
1243                 }
1244 |       SUPER_TK
1245                 {
1246                   tree wfl = build_wfl_node (super_identifier_node);
1247                   EXPR_WFL_LINECOL (wfl) = $1.location;
1248                   $$ = wfl;
1249                 }
1250 ;
1251
1252 /* 19.9 Productions from 9: Interfaces  */
1253 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1254 interface_declaration:
1255         INTERFACE_TK identifier
1256                 { create_interface (0, $2, NULL_TREE); }
1257         interface_body
1258                 { ; }
1259 |       modifiers INTERFACE_TK identifier
1260                 { create_interface ($1, $3, NULL_TREE); }
1261         interface_body
1262                 { ; }
1263 |       INTERFACE_TK identifier extends_interfaces
1264                 { create_interface (0, $2, $3); }
1265         interface_body
1266                 { ; }
1267 |       modifiers INTERFACE_TK identifier extends_interfaces
1268                 { create_interface ($1, $3, $4); }
1269         interface_body
1270                 { ; }
1271 |       INTERFACE_TK identifier error
1272                 { yyerror ("'{' expected"); RECOVER; }
1273 |       modifiers INTERFACE_TK identifier error
1274                 { yyerror ("'{' expected"); RECOVER; }
1275 ;
1276
1277 extends_interfaces:
1278         EXTENDS_TK interface_type
1279                 {
1280                   ctxp->interface_number = 1;
1281                   $$ = build_tree_list ($2, NULL_TREE);
1282                 }
1283 |       extends_interfaces C_TK interface_type
1284                 {
1285                   ctxp->interface_number++;
1286                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1287                 }
1288 |       EXTENDS_TK error
1289                 {yyerror ("Invalid interface type"); RECOVER;}
1290 |       extends_interfaces C_TK error
1291                 {yyerror ("Missing term"); RECOVER;}
1292 ;
1293
1294 interface_body:
1295         OCB_TK CCB_TK
1296                 { $$ = NULL_TREE; }
1297 |       OCB_TK interface_member_declarations CCB_TK
1298                 { $$ = NULL_TREE; }
1299 ;
1300
1301 interface_member_declarations:
1302         interface_member_declaration
1303 |       interface_member_declarations interface_member_declaration
1304 ;
1305
1306 interface_member_declaration:
1307         constant_declaration
1308 |       abstract_method_declaration
1309 |       class_declaration       /* Added, JDK1.1 inner classes */
1310                 { end_class_declaration (1); }
1311 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
1312                 { end_class_declaration (1); }
1313 ;
1314
1315 constant_declaration:
1316         field_declaration
1317 ;
1318
1319 abstract_method_declaration:
1320         method_header SC_TK
1321                 {
1322                   check_abstract_method_header ($1);
1323                   current_function_decl = NULL_TREE; /* FIXME ? */
1324                 }
1325 |       method_header error
1326                 {yyerror ("';' expected"); RECOVER;}
1327 ;
1328
1329 /* 19.10 Productions from 10: Arrays  */
1330 array_initializer:
1331         OCB_TK CCB_TK
1332                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1333 |       OCB_TK C_TK CCB_TK
1334                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1335 |       OCB_TK variable_initializers CCB_TK
1336                 { $$ = build_new_array_init ($1.location, $2); }
1337 |       OCB_TK variable_initializers C_TK CCB_TK
1338                 { $$ = build_new_array_init ($1.location, $2); }
1339 ;
1340
1341 variable_initializers:
1342         variable_initializer
1343                 {
1344                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1345                                   $1, NULL_TREE);
1346                 }
1347 |       variable_initializers C_TK variable_initializer
1348                 {
1349                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1350                 }
1351 |       variable_initializers C_TK error
1352                 {yyerror ("Missing term"); RECOVER;}
1353 ;
1354
1355 /* 19.11 Production from 14: Blocks and Statements  */
1356 block:
1357         block_begin block_end
1358                 { $$ = $2; }
1359 |       block_begin block_statements block_end
1360                 { $$ = $3; }
1361 ;
1362
1363 block_begin:
1364         OCB_TK
1365                 { enter_block (); }
1366 ;
1367
1368 block_end:
1369         CCB_TK
1370                 {
1371                   maybe_absorb_scoping_blocks ();
1372                   /* Store the location of the `}' when doing xrefs */
1373                   if (current_function_decl && flag_emit_xref)
1374                     DECL_END_SOURCE_LINE (current_function_decl) =
1375                       EXPR_WFL_ADD_COL ($1.location, 1);
1376                   $$ = exit_block ();
1377                   if (!BLOCK_SUBBLOCKS ($$))
1378                     BLOCK_SUBBLOCKS ($$) = empty_stmt_node;
1379                 }
1380 ;
1381
1382 block_statements:
1383         block_statement
1384 |       block_statements block_statement
1385 ;
1386
1387 block_statement:
1388         local_variable_declaration_statement
1389 |       statement
1390                 { java_method_add_stmt (current_function_decl, $1); }
1391 |       class_declaration       /* Added, JDK1.1 local classes */
1392                 {
1393                   LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1394                   end_class_declaration (1);
1395                 }
1396 ;
1397
1398 local_variable_declaration_statement:
1399         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1400 ;
1401
1402 local_variable_declaration:
1403         type variable_declarators
1404                 { declare_local_variables (0, $1, $2); }
1405 |       final type variable_declarators /* Added, JDK1.1 final locals */
1406                 { declare_local_variables ($1, $2, $3); }
1407 ;
1408
1409 statement:
1410         statement_without_trailing_substatement
1411 |       labeled_statement
1412 |       if_then_statement
1413 |       if_then_else_statement
1414 |       while_statement
1415 |       for_statement
1416                 { $$ = exit_block (); }
1417 ;
1418
1419 statement_nsi:
1420         statement_without_trailing_substatement
1421 |       labeled_statement_nsi
1422 |       if_then_else_statement_nsi
1423 |       while_statement_nsi
1424 |       for_statement_nsi
1425                 { $$ = exit_block (); }
1426 ;
1427
1428 statement_without_trailing_substatement:
1429         block
1430 |       empty_statement
1431 |       expression_statement
1432 |       switch_statement
1433 |       do_statement
1434 |       break_statement
1435 |       continue_statement
1436 |       return_statement
1437 |       synchronized_statement
1438 |       throw_statement
1439 |       try_statement
1440 |       assert_statement
1441 ;
1442
1443 empty_statement:
1444         SC_TK
1445                 {
1446                   if (flag_extraneous_semicolon
1447                       && ! current_static_block
1448                       && (! current_function_decl ||
1449                           /* Verify we're not in a inner class declaration */
1450                           (GET_CPC () != TYPE_NAME
1451                            (DECL_CONTEXT (current_function_decl)))))
1452
1453                     {
1454                       EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1455                       parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1456                     }
1457                   $$ = empty_stmt_node;
1458                 }
1459 ;
1460
1461 label_decl:
1462         identifier REL_CL_TK
1463                 {
1464                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1465                                             EXPR_WFL_NODE ($1));
1466                   pushlevel (2);
1467                   push_labeled_block ($$);
1468                   PUSH_LABELED_BLOCK ($$);
1469                 }
1470 ;
1471
1472 labeled_statement:
1473         label_decl statement
1474                 { $$ = finish_labeled_statement ($1, $2); }
1475 |       identifier error
1476                 {yyerror ("':' expected"); RECOVER;}
1477 ;
1478
1479 labeled_statement_nsi:
1480         label_decl statement_nsi
1481                 { $$ = finish_labeled_statement ($1, $2); }
1482 ;
1483
1484 /* We concentrate here a bunch of error handling rules that we couldn't write
1485    earlier, because expression_statement catches a missing ';'.  */
1486 expression_statement:
1487         statement_expression SC_TK
1488                 {
1489                   /* We have a statement. Generate a WFL around it so
1490                      we can debug it */
1491                   $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1492                   /* We know we have a statement, so set the debug
1493                      info to be eventually generate here. */
1494                   $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1495                 }
1496 |       error SC_TK
1497                 {
1498                   YYNOT_TWICE yyerror ("Invalid expression statement");
1499                   DRECOVER (expr_stmt);
1500                 }
1501 |       error OCB_TK
1502                 {
1503                   YYNOT_TWICE yyerror ("Invalid expression statement");
1504                   DRECOVER (expr_stmt);
1505                 }
1506 |       error CCB_TK
1507                 {
1508                   YYNOT_TWICE yyerror ("Invalid expression statement");
1509                   DRECOVER (expr_stmt);
1510                 }
1511 |       this_or_super OP_TK error
1512                 {yyerror ("')' expected"); RECOVER;}
1513 |       this_or_super OP_TK CP_TK error
1514                 {
1515                   parse_ctor_invocation_error ();
1516                   RECOVER;
1517                 }
1518 |       this_or_super OP_TK argument_list error
1519                 {yyerror ("')' expected"); RECOVER;}
1520 |       this_or_super OP_TK argument_list CP_TK error
1521                 {
1522                   parse_ctor_invocation_error ();
1523                   RECOVER;
1524                 }
1525 |       name DOT_TK SUPER_TK error
1526                 {yyerror ("'(' expected"); RECOVER;}
1527 |       name DOT_TK SUPER_TK OP_TK error
1528                 {yyerror ("')' expected"); RECOVER;}
1529 |       name DOT_TK SUPER_TK OP_TK argument_list error
1530                 {yyerror ("')' expected"); RECOVER;}
1531 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1532                 {yyerror ("';' expected"); RECOVER;}
1533 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1534                 {yyerror ("';' expected"); RECOVER;}
1535 ;
1536
1537 statement_expression:
1538         assignment
1539 |       pre_increment_expression
1540 |       pre_decrement_expression
1541 |       post_increment_expression
1542 |       post_decrement_expression
1543 |       method_invocation
1544 |       class_instance_creation_expression
1545 ;
1546
1547 if_then_statement:
1548         IF_TK OP_TK expression CP_TK statement
1549                 {
1550                   $$ = build_if_else_statement ($2.location, $3,
1551                                                 $5, NULL_TREE);
1552                 }
1553 |       IF_TK error
1554                 {yyerror ("'(' expected"); RECOVER;}
1555 |       IF_TK OP_TK error
1556                 {yyerror ("Missing term"); RECOVER;}
1557 |       IF_TK OP_TK expression error
1558                 {yyerror ("')' expected"); RECOVER;}
1559 ;
1560
1561 if_then_else_statement:
1562         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1563                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1564 ;
1565
1566 if_then_else_statement_nsi:
1567         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1568                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1569 ;
1570
1571 switch_statement:
1572         switch_expression
1573                 {
1574                   enter_block ();
1575                 }
1576         switch_block
1577                 {
1578                   /* Make into "proper list" of COMPOUND_EXPRs.
1579                      I.e. make the last statement also have its own
1580                      COMPOUND_EXPR. */
1581                   maybe_absorb_scoping_blocks ();
1582                   TREE_OPERAND ($1, 1) = exit_block ();
1583                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1584                 }
1585 ;
1586
1587 switch_expression:
1588         SWITCH_TK OP_TK expression CP_TK
1589                 {
1590                   $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1591                   EXPR_WFL_LINECOL ($$) = $2.location;
1592                 }
1593 |       SWITCH_TK error
1594                 {yyerror ("'(' expected"); RECOVER;}
1595 |       SWITCH_TK OP_TK error
1596                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1597 |       SWITCH_TK OP_TK expression CP_TK error
1598                 {yyerror ("'{' expected"); RECOVER;}
1599 ;
1600
1601 /* Default assignment is there to avoid type node on switch_block
1602    node. */
1603
1604 switch_block:
1605         OCB_TK CCB_TK
1606                 { $$ = NULL_TREE; }
1607 |       OCB_TK switch_labels CCB_TK
1608                 { $$ = NULL_TREE; }
1609 |       OCB_TK switch_block_statement_groups CCB_TK
1610                 { $$ = NULL_TREE; }
1611 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1612                 { $$ = NULL_TREE; }
1613 ;
1614
1615 switch_block_statement_groups:
1616         switch_block_statement_group
1617 |       switch_block_statement_groups switch_block_statement_group
1618 ;
1619
1620 switch_block_statement_group:
1621         switch_labels block_statements
1622 ;
1623
1624 switch_labels:
1625         switch_label
1626 |       switch_labels switch_label
1627 ;
1628
1629 switch_label:
1630         CASE_TK constant_expression REL_CL_TK
1631                 {
1632                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1633                   EXPR_WFL_LINECOL (lab) = $1.location;
1634                   java_method_add_stmt (current_function_decl, lab);
1635                 }
1636 |       DEFAULT_TK REL_CL_TK
1637                 {
1638                   tree lab = make_node (DEFAULT_EXPR);
1639                   EXPR_WFL_LINECOL (lab) = $1.location;
1640                   java_method_add_stmt (current_function_decl, lab);
1641                 }
1642 |       CASE_TK error
1643                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1644 |       CASE_TK constant_expression error
1645                 {yyerror ("':' expected"); RECOVER;}
1646 |       DEFAULT_TK error
1647                 {yyerror ("':' expected"); RECOVER;}
1648 ;
1649
1650 while_expression:
1651         WHILE_TK OP_TK expression CP_TK
1652                 {
1653                   tree body = build_loop_body ($2.location, $3, 0);
1654                   $$ = build_new_loop (body);
1655                 }
1656 ;
1657
1658 while_statement:
1659         while_expression statement
1660                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1661 |       WHILE_TK error
1662                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1663 |       WHILE_TK OP_TK error
1664                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1665 |       WHILE_TK OP_TK expression error
1666                 {yyerror ("')' expected"); RECOVER;}
1667 ;
1668
1669 while_statement_nsi:
1670         while_expression statement_nsi
1671                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1672 ;
1673
1674 do_statement_begin:
1675         DO_TK
1676                 {
1677                   tree body = build_loop_body (0, NULL_TREE, 1);
1678                   $$ = build_new_loop (body);
1679                 }
1680         /* Need error handing here. FIXME */
1681 ;
1682
1683 do_statement:
1684         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1685                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1686 ;
1687
1688 for_statement:
1689         for_begin SC_TK expression SC_TK for_update CP_TK statement
1690                 {
1691                   if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1692                     $3 = build_wfl_node ($3);
1693                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1694                 }
1695 |       for_begin SC_TK SC_TK for_update CP_TK statement
1696                 {
1697                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1698                   /* We have not condition, so we get rid of the EXIT_EXPR */
1699                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1700                     empty_stmt_node;
1701                 }
1702 |       for_begin SC_TK error
1703                 {yyerror ("Invalid control expression"); RECOVER;}
1704 |       for_begin SC_TK expression SC_TK error
1705                 {yyerror ("Invalid update expression"); RECOVER;}
1706 |       for_begin SC_TK SC_TK error
1707                 {yyerror ("Invalid update expression"); RECOVER;}
1708 ;
1709
1710 for_statement_nsi:
1711         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1712                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1713 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1714                 {
1715                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1716                   /* We have not condition, so we get rid of the EXIT_EXPR */
1717                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1718                     empty_stmt_node;
1719                 }
1720 ;
1721
1722 for_header:
1723         FOR_TK OP_TK
1724                 {
1725                   /* This scope defined for local variable that may be
1726                      defined within the scope of the for loop */
1727                   enter_block ();
1728                 }
1729 |       FOR_TK error
1730                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1731 |       FOR_TK OP_TK error
1732                 {yyerror ("Invalid init statement"); RECOVER;}
1733 ;
1734
1735 for_begin:
1736         for_header for_init
1737                 {
1738                   /* We now declare the loop body. The loop is
1739                      declared as a for loop. */
1740                   tree body = build_loop_body (0, NULL_TREE, 0);
1741                   $$ =  build_new_loop (body);
1742                   FOR_LOOP_P ($$) = 1;
1743                   /* The loop is added to the current block the for
1744                      statement is defined within */
1745                   java_method_add_stmt (current_function_decl, $$);
1746                 }
1747 ;
1748 for_init:                       /* Can be empty */
1749                 { $$ = empty_stmt_node; }
1750 |       statement_expression_list
1751                 {
1752                   /* Init statement recorded within the previously
1753                      defined block scope */
1754                   $$ = java_method_add_stmt (current_function_decl, $1);
1755                 }
1756 |       local_variable_declaration
1757                 {
1758                   /* Local variable are recorded within the previously
1759                      defined block scope */
1760                   $$ = NULL_TREE;
1761                 }
1762 |       statement_expression_list error
1763                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1764 ;
1765
1766 for_update:                     /* Can be empty */
1767                 {$$ = empty_stmt_node;}
1768 |       statement_expression_list
1769                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1770 ;
1771
1772 statement_expression_list:
1773         statement_expression
1774                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1775 |       statement_expression_list C_TK statement_expression
1776                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1777 |       statement_expression_list C_TK error
1778                 {yyerror ("Missing term"); RECOVER;}
1779 ;
1780
1781 break_statement:
1782         BREAK_TK SC_TK
1783                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1784 |       BREAK_TK identifier SC_TK
1785                 { $$ = build_bc_statement ($1.location, 1, $2); }
1786 |       BREAK_TK error
1787                 {yyerror ("Missing term"); RECOVER;}
1788 |       BREAK_TK identifier error
1789                 {yyerror ("';' expected"); RECOVER;}
1790 ;
1791
1792 continue_statement:
1793         CONTINUE_TK SC_TK
1794                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1795 |       CONTINUE_TK identifier SC_TK
1796                 { $$ = build_bc_statement ($1.location, 0, $2); }
1797 |       CONTINUE_TK error
1798                 {yyerror ("Missing term"); RECOVER;}
1799 |       CONTINUE_TK identifier error
1800                 {yyerror ("';' expected"); RECOVER;}
1801 ;
1802
1803 return_statement:
1804         RETURN_TK SC_TK
1805                 { $$ = build_return ($1.location, NULL_TREE); }
1806 |       RETURN_TK expression SC_TK
1807                 { $$ = build_return ($1.location, $2); }
1808 |       RETURN_TK error
1809                 {yyerror ("Missing term"); RECOVER;}
1810 |       RETURN_TK expression error
1811                 {yyerror ("';' expected"); RECOVER;}
1812 ;
1813
1814 throw_statement:
1815         THROW_TK expression SC_TK
1816                 {
1817                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1818                   EXPR_WFL_LINECOL ($$) = $1.location;
1819                 }
1820 |       THROW_TK error
1821                 {yyerror ("Missing term"); RECOVER;}
1822 |       THROW_TK expression error
1823                 {yyerror ("';' expected"); RECOVER;}
1824 ;
1825
1826 assert_statement:
1827         ASSERT_TK expression REL_CL_TK expression SC_TK
1828                 {
1829                   $$ = build_assertion ($1.location, $2, $4);
1830                 }
1831 |       ASSERT_TK expression SC_TK
1832                 {
1833                   $$ = build_assertion ($1.location, $2, NULL_TREE);
1834                 }
1835 |       ASSERT_TK error
1836                 {yyerror ("Missing term"); RECOVER;}
1837 |       ASSERT_TK expression error
1838                 {yyerror ("';' expected"); RECOVER;}
1839 ;
1840
1841 synchronized_statement:
1842         synchronized OP_TK expression CP_TK block
1843                 {
1844                   $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1845                   EXPR_WFL_LINECOL ($$) =
1846                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1847                 }
1848 |       synchronized OP_TK expression CP_TK error
1849                 {yyerror ("'{' expected"); RECOVER;}
1850 |       synchronized error
1851                 {yyerror ("'(' expected"); RECOVER;}
1852 |       synchronized OP_TK error CP_TK
1853                 {yyerror ("Missing term"); RECOVER;}
1854 |       synchronized OP_TK error
1855                 {yyerror ("Missing term"); RECOVER;}
1856 ;
1857
1858 synchronized:
1859         modifiers
1860                 {
1861                   check_modifiers (
1862              "Illegal modifier `%s'. Only `synchronized' was expected here",
1863                                    $1, ACC_SYNCHRONIZED);
1864                   if ($1 != ACC_SYNCHRONIZED)
1865                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1866                       build_wfl_node (NULL_TREE);
1867                 }
1868 ;
1869
1870 try_statement:
1871         TRY_TK block catches
1872                 { $$ = build_try_statement ($1.location, $2, $3); }
1873 |       TRY_TK block finally
1874                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1875 |       TRY_TK block catches finally
1876                 { $$ = build_try_finally_statement
1877                     ($1.location, build_try_statement ($1.location,
1878                                                        $2, $3), $4);
1879                 }
1880 |       TRY_TK error
1881                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1882 ;
1883
1884 catches:
1885         catch_clause
1886 |       catches catch_clause
1887                 {
1888                   TREE_CHAIN ($2) = $1;
1889                   $$ = $2;
1890                 }
1891 ;
1892
1893 catch_clause:
1894         catch_clause_parameter block
1895                 {
1896                   java_method_add_stmt (current_function_decl, $2);
1897                   exit_block ();
1898                   $$ = $1;
1899                 }
1900 ;
1901
1902 catch_clause_parameter:
1903         CATCH_TK OP_TK formal_parameter CP_TK
1904                 {
1905                   /* We add a block to define a scope for
1906                      formal_parameter (CCBP). The formal parameter is
1907                      declared initialized by the appropriate function
1908                      call */
1909                   tree ccpb;
1910                   tree init;
1911                   if ($3)
1912                     {
1913                       ccpb = enter_block ();
1914                       init = build_assignment
1915                         (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1916                          build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1917                       declare_local_variables (0, TREE_VALUE ($3),
1918                                                build_tree_list
1919                                                (TREE_PURPOSE ($3), init));
1920                       $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1921                       EXPR_WFL_LINECOL ($$) = $1.location;
1922                     }
1923                   else
1924                     {
1925                       $$ = error_mark_node;
1926                     }
1927                 }
1928 |       CATCH_TK error
1929                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1930 |       CATCH_TK OP_TK error
1931                 {
1932                   yyerror ("Missing term or ')' expected");
1933                   RECOVER; $$ = NULL_TREE;
1934                 }
1935 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1936                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1937 ;
1938
1939 finally:
1940         FINALLY_TK block
1941                 { $$ = $2; }
1942 |       FINALLY_TK error
1943                 {yyerror ("'{' expected"); RECOVER; }
1944 ;
1945
1946 /* 19.12 Production from 15: Expressions  */
1947 primary:
1948         primary_no_new_array
1949 |       array_creation_expression
1950 ;
1951
1952 primary_no_new_array:
1953         literal
1954 |       THIS_TK
1955                 { $$ = build_this ($1.location); }
1956 |       OP_TK expression CP_TK
1957                 {$$ = $2;}
1958 |       class_instance_creation_expression
1959 |       field_access
1960 |       method_invocation
1961 |       array_access
1962 |       type_literals
1963         /* Added, JDK1.1 inner classes. Documentation is wrong
1964            refering to a 'ClassName' (class_name) rule that doesn't
1965            exist. Used name: instead.  */
1966 |       name DOT_TK THIS_TK
1967                 {
1968                   tree wfl = build_wfl_node (this_identifier_node);
1969                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1970                 }
1971 |       OP_TK expression error
1972                 {yyerror ("')' expected"); RECOVER;}
1973 |       name DOT_TK error
1974                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1975 |       primitive_type DOT_TK error
1976                 {yyerror ("'class' expected" ); RECOVER;}
1977 |       VOID_TK DOT_TK error
1978                 {yyerror ("'class' expected" ); RECOVER;}
1979 ;
1980
1981 type_literals:
1982         name DOT_TK CLASS_TK
1983                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1984 |       array_type DOT_TK CLASS_TK
1985                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1986 |       primitive_type DOT_TK CLASS_TK
1987                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1988 |       VOID_TK DOT_TK CLASS_TK
1989                 {
1990                    $$ = build_incomplete_class_ref ($2.location,
1991                                                    void_type_node);
1992                 }
1993 ;
1994
1995 class_instance_creation_expression:
1996         NEW_TK class_type OP_TK argument_list CP_TK
1997                 { $$ = build_new_invocation ($2, $4); }
1998 |       NEW_TK class_type OP_TK CP_TK
1999                 { $$ = build_new_invocation ($2, NULL_TREE); }
2000 |       anonymous_class_creation
2001         /* Added, JDK1.1 inner classes, modified to use name or
2002            primary instead of primary solely which couldn't work in
2003            all situations.  */
2004 |       something_dot_new identifier OP_TK CP_TK
2005                 {
2006                   tree ctor = build_new_invocation ($2, NULL_TREE);
2007                   $$ = make_qualified_primary ($1, ctor,
2008                                                EXPR_WFL_LINECOL ($1));
2009                 }
2010 |       something_dot_new identifier OP_TK CP_TK class_body
2011 |       something_dot_new identifier OP_TK argument_list CP_TK
2012                 {
2013                   tree ctor = build_new_invocation ($2, $4);
2014                   $$ = make_qualified_primary ($1, ctor,
2015                                                EXPR_WFL_LINECOL ($1));
2016                 }
2017 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2018 |       NEW_TK error SC_TK
2019                 {yyerror ("'(' expected"); DRECOVER(new_1);}
2020 |       NEW_TK class_type error
2021                 {yyerror ("'(' expected"); RECOVER;}
2022 |       NEW_TK class_type OP_TK error
2023                 {yyerror ("')' or term expected"); RECOVER;}
2024 |       NEW_TK class_type OP_TK argument_list error
2025                 {yyerror ("')' expected"); RECOVER;}
2026 |       something_dot_new error
2027                 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2028 |       something_dot_new identifier error
2029                 {yyerror ("'(' expected"); RECOVER;}
2030 ;
2031
2032 /* Created after JDK1.1 rules originally added to
2033    class_instance_creation_expression, but modified to use
2034    'class_type' instead of 'TypeName' (type_name) which is mentioned
2035    in the documentation but doesn't exist. */
2036
2037 anonymous_class_creation:
2038         NEW_TK class_type OP_TK argument_list CP_TK
2039                 { create_anonymous_class ($1.location, $2); }
2040         class_body
2041                 {
2042                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2043                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2044
2045                   end_class_declaration (1);
2046
2047                   /* Now we can craft the new expression */
2048                   $$ = build_new_invocation (id, $4);
2049
2050                   /* Note that we can't possibly be here if
2051                      `class_type' is an interface (in which case the
2052                      anonymous class extends Object and implements
2053                      `class_type', hence its constructor can't have
2054                      arguments.) */
2055
2056                   /* Otherwise, the innerclass must feature a
2057                      constructor matching `argument_list'. Anonymous
2058                      classes are a bit special: it's impossible to
2059                      define constructor for them, hence constructors
2060                      must be generated following the hints provided by
2061                      the `new' expression. Whether a super constructor
2062                      of that nature exists or not is to be verified
2063                      later on in verify_constructor_super.
2064
2065                      It's during the expansion of a `new' statement
2066                      refering to an anonymous class that a ctor will
2067                      be generated for the anonymous class, with the
2068                      right arguments. */
2069
2070                 }
2071 |       NEW_TK class_type OP_TK CP_TK
2072                 { create_anonymous_class ($1.location, $2); }
2073         class_body
2074                 {
2075                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2076                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2077
2078                   end_class_declaration (1);
2079
2080                   /* Now we can craft the new expression. The
2081                      statement doesn't need to be remember so that a
2082                      constructor can be generated, since its signature
2083                      is already known. */
2084                   $$ = build_new_invocation (id, NULL_TREE);
2085                 }
2086 ;
2087
2088 something_dot_new:              /* Added, not part of the specs. */
2089         name DOT_TK NEW_TK
2090                 { $$ = $1; }
2091 |       primary DOT_TK NEW_TK
2092                 { $$ = $1; }
2093 ;
2094
2095 argument_list:
2096         expression
2097                 {
2098                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2099                   ctxp->formal_parameter_number = 1;
2100                 }
2101 |       argument_list C_TK expression
2102                 {
2103                   ctxp->formal_parameter_number += 1;
2104                   $$ = tree_cons (NULL_TREE, $3, $1);
2105                 }
2106 |       argument_list C_TK error
2107                 {yyerror ("Missing term"); RECOVER;}
2108 ;
2109
2110 array_creation_expression:
2111         NEW_TK primitive_type dim_exprs
2112                 { $$ = build_newarray_node ($2, $3, 0); }
2113 |       NEW_TK class_or_interface_type dim_exprs
2114                 { $$ = build_newarray_node ($2, $3, 0); }
2115 |       NEW_TK primitive_type dim_exprs dims
2116                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2117 |       NEW_TK class_or_interface_type dim_exprs dims
2118                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2119         /* Added, JDK1.1 anonymous array. Initial documentation rule
2120            modified */
2121 |       NEW_TK class_or_interface_type dims array_initializer
2122                 {
2123                   char *sig;
2124                   int osb = pop_current_osb (ctxp);
2125                   while (osb--)
2126                     obstack_grow (&temporary_obstack, "[]", 2);
2127                   obstack_1grow (&temporary_obstack, '\0');
2128                   sig = obstack_finish (&temporary_obstack);
2129                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2130                               $2, get_identifier (sig), $4);
2131                 }
2132 |       NEW_TK primitive_type dims array_initializer
2133                 {
2134                   int osb = pop_current_osb (ctxp);
2135                   tree type = $2;
2136                   while (osb--)
2137                     type = build_java_array_type (type, -1);
2138                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2139                               build_pointer_type (type), NULL_TREE, $4);
2140                 }
2141 |       NEW_TK error CSB_TK
2142                 {yyerror ("'[' expected"); DRECOVER ("]");}
2143 |       NEW_TK error OSB_TK
2144                 {yyerror ("']' expected"); RECOVER;}
2145 ;
2146
2147 dim_exprs:
2148         dim_expr
2149                 { $$ = build_tree_list (NULL_TREE, $1); }
2150 |       dim_exprs dim_expr
2151                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2152 ;
2153
2154 dim_expr:
2155         OSB_TK expression CSB_TK
2156                 {
2157                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2158                     {
2159                       $2 = build_wfl_node ($2);
2160                       TREE_TYPE ($2) = NULL_TREE;
2161                     }
2162                   EXPR_WFL_LINECOL ($2) = $1.location;
2163                   $$ = $2;
2164                 }
2165 |       OSB_TK expression error
2166                 {yyerror ("']' expected"); RECOVER;}
2167 |       OSB_TK error
2168                 {
2169                   yyerror ("Missing term");
2170                   yyerror ("']' expected");
2171                   RECOVER;
2172                 }
2173 ;
2174
2175 dims:
2176         OSB_TK CSB_TK
2177                 {
2178                   int allocate = 0;
2179                   /* If not initialized, allocate memory for the osb
2180                      numbers stack */
2181                   if (!ctxp->osb_limit)
2182                     {
2183                       allocate = ctxp->osb_limit = 32;
2184                       ctxp->osb_depth = -1;
2185                     }
2186                   /* If capacity overflown, reallocate a bigger chunk */
2187                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2188                     allocate = ctxp->osb_limit << 1;
2189
2190                   if (allocate)
2191                     {
2192                       allocate *= sizeof (int);
2193                       if (ctxp->osb_number)
2194                         ctxp->osb_number = xrealloc (ctxp->osb_number,
2195                                                      allocate);
2196                       else
2197                         ctxp->osb_number = xmalloc (allocate);
2198                     }
2199                   ctxp->osb_depth++;
2200                   CURRENT_OSB (ctxp) = 1;
2201                 }
2202 |       dims OSB_TK CSB_TK
2203                 { CURRENT_OSB (ctxp)++; }
2204 |       dims OSB_TK error
2205                 { yyerror ("']' expected"); RECOVER;}
2206 ;
2207
2208 field_access:
2209         primary DOT_TK identifier
2210                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2211                 /*  FIXME - REWRITE TO:
2212                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2213 |       SUPER_TK DOT_TK identifier
2214                 {
2215                   tree super_wfl = build_wfl_node (super_identifier_node);
2216                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
2217                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2218                 }
2219 |       SUPER_TK error
2220                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2221 ;
2222
2223 method_invocation:
2224         name OP_TK CP_TK
2225                 { $$ = build_method_invocation ($1, NULL_TREE); }
2226 |       name OP_TK argument_list CP_TK
2227                 { $$ = build_method_invocation ($1, $3); }
2228 |       primary DOT_TK identifier OP_TK CP_TK
2229                 {
2230                   if (TREE_CODE ($1) == THIS_EXPR)
2231                     $$ = build_this_super_qualified_invocation
2232                       (1, $3, NULL_TREE, 0, $2.location);
2233                   else
2234                     {
2235                       tree invok = build_method_invocation ($3, NULL_TREE);
2236                       $$ = make_qualified_primary ($1, invok, $2.location);
2237                     }
2238                 }
2239 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2240                 {
2241                   if (TREE_CODE ($1) == THIS_EXPR)
2242                     $$ = build_this_super_qualified_invocation
2243                       (1, $3, $5, 0, $2.location);
2244                   else
2245                     {
2246                       tree invok = build_method_invocation ($3, $5);
2247                       $$ = make_qualified_primary ($1, invok, $2.location);
2248                     }
2249                 }
2250 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2251                 {
2252                   $$ = build_this_super_qualified_invocation
2253                     (0, $3, NULL_TREE, $1.location, $2.location);
2254                 }
2255 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2256                 {
2257                   $$ = build_this_super_qualified_invocation
2258                     (0, $3, $5, $1.location, $2.location);
2259                 }
2260         /* Screws up thing. I let it here until I'm convinced it can
2261            be removed. FIXME
2262 |       primary DOT_TK error
2263                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2264 |       SUPER_TK DOT_TK error CP_TK
2265                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2266 |       SUPER_TK DOT_TK error DOT_TK
2267                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2268 ;
2269
2270 array_access:
2271         name OSB_TK expression CSB_TK
2272                 { $$ = build_array_ref ($2.location, $1, $3); }
2273 |       primary_no_new_array OSB_TK expression CSB_TK
2274                 { $$ = build_array_ref ($2.location, $1, $3); }
2275 |       name OSB_TK error
2276                 {
2277                   yyerror ("Missing term and ']' expected");
2278                   DRECOVER(array_access);
2279                 }
2280 |       name OSB_TK expression error
2281                 {
2282                   yyerror ("']' expected");
2283                   DRECOVER(array_access);
2284                 }
2285 |       primary_no_new_array OSB_TK error
2286                 {
2287                   yyerror ("Missing term and ']' expected");
2288                   DRECOVER(array_access);
2289                 }
2290 |       primary_no_new_array OSB_TK expression error
2291                 {
2292                   yyerror ("']' expected");
2293                   DRECOVER(array_access);
2294                 }
2295 ;
2296
2297 postfix_expression:
2298         primary
2299 |       name
2300 |       post_increment_expression
2301 |       post_decrement_expression
2302 ;
2303
2304 post_increment_expression:
2305         postfix_expression INCR_TK
2306                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2307 ;
2308
2309 post_decrement_expression:
2310         postfix_expression DECR_TK
2311                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2312 ;
2313
2314 trap_overflow_corner_case:
2315         pre_increment_expression
2316 |       pre_decrement_expression
2317 |       PLUS_TK unary_expression
2318                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2319 |       unary_expression_not_plus_minus
2320 |       PLUS_TK error
2321                 {yyerror ("Missing term"); RECOVER}
2322 ;
2323
2324 unary_expression:
2325         trap_overflow_corner_case
2326                 {
2327                   error_if_numeric_overflow ($1);
2328                   $$ = $1;
2329                 }
2330 |       MINUS_TK trap_overflow_corner_case
2331                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2332 |       MINUS_TK error
2333                 {yyerror ("Missing term"); RECOVER}
2334 ;
2335
2336 pre_increment_expression:
2337         INCR_TK unary_expression
2338                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2339 |       INCR_TK error
2340                 {yyerror ("Missing term"); RECOVER}
2341 ;
2342
2343 pre_decrement_expression:
2344         DECR_TK unary_expression
2345                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2346 |       DECR_TK error
2347                 {yyerror ("Missing term"); RECOVER}
2348 ;
2349
2350 unary_expression_not_plus_minus:
2351         postfix_expression
2352 |       NOT_TK unary_expression
2353                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2354 |       NEG_TK unary_expression
2355                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2356 |       cast_expression
2357 |       NOT_TK error
2358                 {yyerror ("Missing term"); RECOVER}
2359 |       NEG_TK error
2360                 {yyerror ("Missing term"); RECOVER}
2361 ;
2362
2363 cast_expression:                /* Error handling here is potentially weak */
2364         OP_TK primitive_type dims CP_TK unary_expression
2365                 {
2366                   tree type = $2;
2367                   int osb = pop_current_osb (ctxp);
2368                   while (osb--)
2369                     type = build_java_array_type (type, -1);
2370                   $$ = build_cast ($1.location, type, $5);
2371                 }
2372 |       OP_TK primitive_type CP_TK unary_expression
2373                 { $$ = build_cast ($1.location, $2, $4); }
2374 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2375                 { $$ = build_cast ($1.location, $2, $4); }
2376 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2377                 {
2378                   const char *ptr;
2379                   int osb = pop_current_osb (ctxp);
2380                   obstack_grow (&temporary_obstack,
2381                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2382                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2383                   while (osb--)
2384                     obstack_grow (&temporary_obstack, "[]", 2);
2385                   obstack_1grow (&temporary_obstack, '\0');
2386                   ptr = obstack_finish (&temporary_obstack);
2387                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2388                   $$ = build_cast ($1.location, $2, $5);
2389                 }
2390 |       OP_TK primitive_type OSB_TK error
2391                 {yyerror ("']' expected, invalid type expression");}
2392 |       OP_TK error
2393                 {
2394                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2395                   RECOVER;
2396                 }
2397 |       OP_TK primitive_type dims CP_TK error
2398                 {yyerror ("Missing term"); RECOVER;}
2399 |       OP_TK primitive_type CP_TK error
2400                 {yyerror ("Missing term"); RECOVER;}
2401 |       OP_TK name dims CP_TK error
2402                 {yyerror ("Missing term"); RECOVER;}
2403 ;
2404
2405 multiplicative_expression:
2406         unary_expression
2407 |       multiplicative_expression MULT_TK unary_expression
2408                 {
2409                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2410                                     $2.location, $1, $3);
2411                 }
2412 |       multiplicative_expression DIV_TK unary_expression
2413                 {
2414                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2415                                     $1, $3);
2416                 }
2417 |       multiplicative_expression REM_TK unary_expression
2418                 {
2419                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2420                                     $1, $3);
2421                 }
2422 |       multiplicative_expression MULT_TK error
2423                 {yyerror ("Missing term"); RECOVER;}
2424 |       multiplicative_expression DIV_TK error
2425                 {yyerror ("Missing term"); RECOVER;}
2426 |       multiplicative_expression REM_TK error
2427                 {yyerror ("Missing term"); RECOVER;}
2428 ;
2429
2430 additive_expression:
2431         multiplicative_expression
2432 |       additive_expression PLUS_TK multiplicative_expression
2433                 {
2434                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2435                                     $1, $3);
2436                 }
2437 |       additive_expression MINUS_TK multiplicative_expression
2438                 {
2439                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2440                                     $1, $3);
2441                 }
2442 |       additive_expression PLUS_TK error
2443                 {yyerror ("Missing term"); RECOVER;}
2444 |       additive_expression MINUS_TK error
2445                 {yyerror ("Missing term"); RECOVER;}
2446 ;
2447
2448 shift_expression:
2449         additive_expression
2450 |       shift_expression LS_TK additive_expression
2451                 {
2452                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2453                                     $1, $3);
2454                 }
2455 |       shift_expression SRS_TK additive_expression
2456                 {
2457                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2458                                     $1, $3);
2459                 }
2460 |       shift_expression ZRS_TK additive_expression
2461                 {
2462                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2463                                     $1, $3);
2464                 }
2465 |       shift_expression LS_TK error
2466                 {yyerror ("Missing term"); RECOVER;}
2467 |       shift_expression SRS_TK error
2468                 {yyerror ("Missing term"); RECOVER;}
2469 |       shift_expression ZRS_TK error
2470                 {yyerror ("Missing term"); RECOVER;}
2471 ;
2472
2473 relational_expression:
2474         shift_expression
2475 |       relational_expression LT_TK shift_expression
2476                 {
2477                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2478                                     $1, $3);
2479                 }
2480 |       relational_expression GT_TK shift_expression
2481                 {
2482                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2483                                     $1, $3);
2484                 }
2485 |       relational_expression LTE_TK shift_expression
2486                 {
2487                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2488                                     $1, $3);
2489                 }
2490 |       relational_expression GTE_TK shift_expression
2491                 {
2492                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2493                                     $1, $3);
2494                 }
2495 |       relational_expression INSTANCEOF_TK reference_type
2496                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2497 |       relational_expression LT_TK error
2498                 {yyerror ("Missing term"); RECOVER;}
2499 |       relational_expression GT_TK error
2500                 {yyerror ("Missing term"); RECOVER;}
2501 |       relational_expression LTE_TK error
2502                 {yyerror ("Missing term"); RECOVER;}
2503 |       relational_expression GTE_TK error
2504                 {yyerror ("Missing term"); RECOVER;}
2505 |       relational_expression INSTANCEOF_TK error
2506                 {yyerror ("Invalid reference type"); RECOVER;}
2507 ;
2508
2509 equality_expression:
2510         relational_expression
2511 |       equality_expression EQ_TK relational_expression
2512                 {
2513                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2514                                     $1, $3);
2515                 }
2516 |       equality_expression NEQ_TK relational_expression
2517                 {
2518                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2519                                     $1, $3);
2520                 }
2521 |       equality_expression EQ_TK error
2522                 {yyerror ("Missing term"); RECOVER;}
2523 |       equality_expression NEQ_TK error
2524                 {yyerror ("Missing term"); RECOVER;}
2525 ;
2526
2527 and_expression:
2528         equality_expression
2529 |       and_expression AND_TK equality_expression
2530                 {
2531                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2532                                     $1, $3);
2533                 }
2534 |       and_expression AND_TK error
2535                 {yyerror ("Missing term"); RECOVER;}
2536 ;
2537
2538 exclusive_or_expression:
2539         and_expression
2540 |       exclusive_or_expression XOR_TK and_expression
2541                 {
2542                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2543                                     $1, $3);
2544                 }
2545 |       exclusive_or_expression XOR_TK error
2546                 {yyerror ("Missing term"); RECOVER;}
2547 ;
2548
2549 inclusive_or_expression:
2550         exclusive_or_expression
2551 |       inclusive_or_expression OR_TK exclusive_or_expression
2552                 {
2553                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2554                                     $1, $3);
2555                 }
2556 |       inclusive_or_expression OR_TK error
2557                 {yyerror ("Missing term"); RECOVER;}
2558 ;
2559
2560 conditional_and_expression:
2561         inclusive_or_expression
2562 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2563                 {
2564                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2565                                     $1, $3);
2566                 }
2567 |       conditional_and_expression BOOL_AND_TK error
2568                 {yyerror ("Missing term"); RECOVER;}
2569 ;
2570
2571 conditional_or_expression:
2572         conditional_and_expression
2573 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2574                 {
2575                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2576                                     $1, $3);
2577                 }
2578 |       conditional_or_expression BOOL_OR_TK error
2579                 {yyerror ("Missing term"); RECOVER;}
2580 ;
2581
2582 conditional_expression:         /* Error handling here is weak */
2583         conditional_or_expression
2584 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2585                 {
2586                   $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2587                   EXPR_WFL_LINECOL ($$) = $2.location;
2588                 }
2589 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2590                 {
2591                   YYERROR_NOW;
2592                   yyerror ("Missing term");
2593                   DRECOVER (1);
2594                 }
2595 |       conditional_or_expression REL_QM_TK error
2596                 {yyerror ("Missing term"); DRECOVER (2);}
2597 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2598                 {yyerror ("Missing term"); DRECOVER (3);}
2599 ;
2600
2601 assignment_expression:
2602         conditional_expression
2603 |       assignment
2604 ;
2605
2606 assignment:
2607         left_hand_side assignment_operator assignment_expression
2608                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2609 |       left_hand_side assignment_operator error
2610                 {
2611                   YYNOT_TWICE yyerror ("Missing term");
2612                   DRECOVER (assign);
2613                 }
2614 ;
2615
2616 left_hand_side:
2617         name
2618 |       field_access
2619 |       array_access
2620 ;
2621
2622 assignment_operator:
2623         ASSIGN_ANY_TK
2624 |       ASSIGN_TK
2625 ;
2626
2627 expression:
2628         assignment_expression
2629 ;
2630
2631 constant_expression:
2632         expression
2633 ;
2634
2635 %%
2636
2637 /* Helper function to retrieve an OSB count. Should be used when the
2638    `dims:' rule is being used.  */
2639
2640 static int
2641 pop_current_osb (struct parser_ctxt *ctxp)
2642 {
2643   int to_return;
2644
2645   if (ctxp->osb_depth < 0)
2646     abort ();
2647
2648   to_return = CURRENT_OSB (ctxp);
2649   ctxp->osb_depth--;
2650
2651   return to_return;
2652 }
2653
2654 \f
2655
2656 /* This section of the code deal with save/restoring parser contexts.
2657    Add mode documentation here. FIXME */
2658
2659 /* Helper function. Create a new parser context. With
2660    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2661    context is copied, otherwise, the new context is zeroed. The newly
2662    created context becomes the current one.  */
2663
2664 static void
2665 create_new_parser_context (int copy_from_previous)
2666 {
2667   struct parser_ctxt *new;
2668
2669   new = ggc_alloc (sizeof (struct parser_ctxt));
2670   if (copy_from_previous)
2671     {
2672       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2673       /* This flag, indicating the context saves global values,
2674          should only be set by java_parser_context_save_global.  */
2675       new->saved_data_ctx = 0;
2676     }
2677   else
2678     memset (new, 0, sizeof (struct parser_ctxt));
2679
2680   new->next = ctxp;
2681   ctxp = new;
2682 }
2683
2684 /* Create a new parser context and make it the current one. */
2685
2686 void
2687 java_push_parser_context (void)
2688 {
2689   create_new_parser_context (0);
2690 }
2691
2692 void
2693 java_pop_parser_context (int generate)
2694 {
2695   tree current;
2696   struct parser_ctxt *toFree, *next;
2697
2698   if (!ctxp)
2699     return;
2700
2701   toFree = ctxp;
2702   next = ctxp->next;
2703   if (next)
2704     {
2705       input_line = ctxp->lineno;
2706       current_class = ctxp->class_type;
2707     }
2708
2709   /* If the old and new lexers differ, then free the old one.  */
2710   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2711     java_destroy_lexer (ctxp->lexer);
2712
2713   /* Set the single import class file flag to 0 for the current list
2714      of imported things */
2715   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2716     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2717
2718   /* And restore those of the previous context */
2719   if ((ctxp = next))            /* Assignment is really meant here */
2720     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2721       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2722
2723   /* If we pushed a context to parse a class intended to be generated,
2724      we keep it so we can remember the class. What we could actually
2725      do is to just update a list of class names.  */
2726   if (generate)
2727     {
2728       toFree->next = ctxp_for_generation;
2729       ctxp_for_generation = toFree;
2730     }
2731 }
2732
2733 /* Create a parser context for the use of saving some global
2734    variables.  */
2735
2736 void
2737 java_parser_context_save_global (void)
2738 {
2739   if (!ctxp)
2740     {
2741       java_push_parser_context ();
2742       ctxp->saved_data_ctx = 1;
2743     }
2744
2745   /* If this context already stores data, create a new one suitable
2746      for data storage. */
2747   else if (ctxp->saved_data)
2748     {
2749       create_new_parser_context (1);
2750       ctxp->saved_data_ctx = 1;
2751     }
2752
2753   ctxp->lineno = input_line;
2754   ctxp->class_type = current_class;
2755   ctxp->filename = input_filename;
2756   ctxp->function_decl = current_function_decl;
2757   ctxp->saved_data = 1;
2758 }
2759
2760 /* Restore some global variables from the previous context. Make the
2761    previous context the current one.  */
2762
2763 void
2764 java_parser_context_restore_global (void)
2765 {
2766   input_line = ctxp->lineno;
2767   current_class = ctxp->class_type;
2768   input_filename = ctxp->filename;
2769   if (wfl_operator)
2770     {
2771       tree s;
2772       BUILD_FILENAME_IDENTIFIER_NODE (s, input_filename);
2773       EXPR_WFL_FILENAME_NODE (wfl_operator) = s;
2774     }
2775   current_function_decl = ctxp->function_decl;
2776   ctxp->saved_data = 0;
2777   if (ctxp->saved_data_ctx)
2778     java_pop_parser_context (0);
2779 }
2780
2781 /* Suspend vital data for the current class/function being parsed so
2782    that an other class can be parsed. Used to let local/anonymous
2783    classes be parsed.  */
2784
2785 static void
2786 java_parser_context_suspend (void)
2787 {
2788   /* This makes debugging through java_debug_context easier */
2789   static const char *const name = "<inner buffer context>";
2790
2791   /* Duplicate the previous context, use it to save the globals we're
2792      interested in */
2793   create_new_parser_context (1);
2794   ctxp->function_decl = current_function_decl;
2795   ctxp->class_type = current_class;
2796
2797   /* Then create a new context which inherits all data from the
2798      previous one. This will be the new current context  */
2799   create_new_parser_context (1);
2800
2801   /* Help debugging */
2802   ctxp->next->filename = name;
2803 }
2804
2805 /* Resume vital data for the current class/function being parsed so
2806    that an other class can be parsed. Used to let local/anonymous
2807    classes be parsed.  The trick is the data storing file position
2808    informations must be restored to their current value, so parsing
2809    can resume as if no context was ever saved. */
2810
2811 static void
2812 java_parser_context_resume (void)
2813 {
2814   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2815   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2816   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2817
2818   /* We need to inherit the list of classes to complete/generate */
2819   restored->classd_list = old->classd_list;
2820   restored->class_list = old->class_list;
2821
2822   /* Restore the current class and function from the saver */
2823   current_class = saver->class_type;
2824   current_function_decl = saver->function_decl;
2825
2826   /* Retrieve the restored context */
2827   ctxp = restored;
2828
2829   /* Re-installed the data for the parsing to carry on */
2830   memcpy (&ctxp->marker_begining, &old->marker_begining,
2831           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2832 }
2833
2834 /* Add a new anchor node to which all statement(s) initializing static
2835    and non static initialized upon declaration field(s) will be
2836    linked.  */
2837
2838 static void
2839 java_parser_context_push_initialized_field (void)
2840 {
2841   tree node;
2842
2843   node = build_tree_list (NULL_TREE, NULL_TREE);
2844   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2845   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2846
2847   node = build_tree_list (NULL_TREE, NULL_TREE);
2848   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2849   CPC_INITIALIZER_LIST (ctxp) = node;
2850
2851   node = build_tree_list (NULL_TREE, NULL_TREE);
2852   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2853   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2854 }
2855
2856 /* Pop the lists of initialized field. If this lists aren't empty,
2857    remember them so we can use it to create and populate the finit$
2858    or <clinit> functions. */
2859
2860 static void
2861 java_parser_context_pop_initialized_field (void)
2862 {
2863   tree stmts;
2864   tree class_type = TREE_TYPE (GET_CPC ());
2865
2866   if (CPC_INITIALIZER_LIST (ctxp))
2867     {
2868       stmts = CPC_INITIALIZER_STMT (ctxp);
2869       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2870       if (stmts && !java_error_count)
2871         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2872     }
2873
2874   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2875     {
2876       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2877       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2878         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2879       /* Keep initialization in order to enforce 8.5 */
2880       if (stmts && !java_error_count)
2881         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2882     }
2883
2884   /* JDK 1.1 instance initializers */
2885   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2886     {
2887       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2888       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2889         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2890       if (stmts && !java_error_count)
2891         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2892     }
2893 }
2894
2895 static tree
2896 reorder_static_initialized (tree list)
2897 {
2898   /* We have to keep things in order. The alias initializer have to
2899      come first, then the initialized regular field, in reverse to
2900      keep them in lexical order. */
2901   tree marker, previous = NULL_TREE;
2902   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2903     if (TREE_CODE (marker) == TREE_LIST
2904         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2905       break;
2906
2907   /* No static initialized, the list is fine as is */
2908   if (!previous)
2909     list = TREE_CHAIN (marker);
2910
2911   /* No marker? reverse the whole list */
2912   else if (!marker)
2913     list = nreverse (list);
2914
2915   /* Otherwise, reverse what's after the marker and the new reordered
2916      sublist will replace the marker. */
2917   else
2918     {
2919       TREE_CHAIN (previous) = NULL_TREE;
2920       list = nreverse (list);
2921       list = chainon (TREE_CHAIN (marker), list);
2922     }
2923   return list;
2924 }
2925
2926 /* Helper functions to dump the parser context stack.  */
2927
2928 #define TAB_CONTEXT(C) \
2929   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2930
2931 static void
2932 java_debug_context_do (int tab)
2933 {
2934   struct parser_ctxt *copy = ctxp;
2935   while (copy)
2936     {
2937       TAB_CONTEXT (tab);
2938       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2939       TAB_CONTEXT (tab);
2940       fprintf (stderr, "filename: %s\n", copy->filename);
2941       TAB_CONTEXT (tab);
2942       fprintf (stderr, "lineno: %d\n", copy->lineno);
2943       TAB_CONTEXT (tab);
2944       fprintf (stderr, "package: %s\n",
2945                (copy->package ?
2946                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2947       TAB_CONTEXT (tab);
2948       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2949       TAB_CONTEXT (tab);
2950       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2951       copy = copy->next;
2952       tab += 2;
2953     }
2954 }
2955
2956 /* Dump the stacked up parser contexts. Intended to be called from a
2957    debugger.  */
2958
2959 void
2960 java_debug_context (void)
2961 {
2962   java_debug_context_do (0);
2963 }
2964
2965 \f
2966
2967 /* Flag for the error report routine to issue the error the first time
2968    it's called (overriding the default behavior which is to drop the
2969    first invocation and honor the second one, taking advantage of a
2970    richer context.  */
2971 static int force_error = 0;
2972
2973 /* Reporting an constructor invocation error.  */
2974 static void
2975 parse_ctor_invocation_error (void)
2976 {
2977   if (DECL_CONSTRUCTOR_P (current_function_decl))
2978     yyerror ("Constructor invocation must be first thing in a constructor");
2979   else
2980     yyerror ("Only constructors can invoke constructors");
2981 }
2982
2983 /* Reporting JDK1.1 features not implemented.  */
2984
2985 static tree
2986 parse_jdk1_1_error (const char *msg)
2987 {
2988   sorry (": `%s' JDK1.1(TM) feature", msg);
2989   java_error_count++;
2990   return empty_stmt_node;
2991 }
2992
2993 static int do_warning = 0;
2994
2995 void
2996 yyerror (const char *msg)
2997 {
2998   static java_lc elc;
2999   static int  prev_lineno;
3000   static const char *prev_msg;
3001
3002   int save_lineno;
3003   char *remainder, *code_from_source;
3004
3005   if (!force_error && prev_lineno == input_line)
3006     return;
3007
3008   /* Save current error location but report latter, when the context is
3009      richer.  */
3010   if (ctxp->java_error_flag == 0)
3011     {
3012       ctxp->java_error_flag = 1;
3013       elc = ctxp->elc;
3014       /* Do something to use the previous line if we're reaching the
3015          end of the file... */
3016 #ifdef VERBOSE_SKELETON
3017       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3018 #endif
3019       return;
3020     }
3021
3022   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3023   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3024     return;
3025
3026   ctxp->java_error_flag = 0;
3027   if (do_warning)
3028     java_warning_count++;
3029   else
3030     java_error_count++;
3031
3032   if (elc.col == 0 && msg && msg[1] == ';')
3033     {
3034       elc.col  = ctxp->p_line->char_col-1;
3035       elc.line = ctxp->p_line->lineno;
3036     }
3037
3038   save_lineno = input_line;
3039   prev_lineno = input_line = elc.line;
3040   prev_msg = msg;
3041
3042   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3043   obstack_grow0 (&temporary_obstack,
3044                  code_from_source, strlen (code_from_source));
3045   remainder = obstack_finish (&temporary_obstack);
3046   if (do_warning)
3047     warning ("%s.\n%s", msg, remainder);
3048   else
3049     error ("%s.\n%s", msg, remainder);
3050
3051   /* This allow us to cheaply avoid an extra 'Invalid expression
3052      statement' error report when errors have been already reported on
3053      the same line. This occurs when we report an error but don't have
3054      a synchronization point other than ';', which
3055      expression_statement is the only one to take care of.  */
3056   ctxp->prevent_ese = input_line = save_lineno;
3057 }
3058
3059 static void
3060 issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
3061 {
3062   const char *saved, *saved_input_filename;
3063   char buffer [4096];
3064   vsprintf (buffer, msg, ap);
3065   force_error = 1;
3066
3067   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3068   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3069                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3070
3071   /* We have a CL, that's a good reason for using it if it contains data */
3072   saved = ctxp->filename;
3073   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3074     ctxp->filename = EXPR_WFL_FILENAME (cl);
3075   saved_input_filename = input_filename;
3076   input_filename = ctxp->filename;
3077   java_error (NULL);
3078   java_error (buffer);
3079   ctxp->filename = saved;
3080   input_filename = saved_input_filename;
3081   force_error = 0;
3082 }
3083
3084 /* Issue an error message at a current source line CL */
3085
3086 void
3087 parse_error_context (tree cl, const char *msg, ...)
3088 {
3089   va_list ap;
3090   va_start (ap, msg);
3091   issue_warning_error_from_context (cl, msg, ap);
3092   va_end (ap);
3093 }
3094
3095 /* Issue a warning at a current source line CL */
3096
3097 static void
3098 parse_warning_context (tree cl, const char *msg, ...)
3099 {
3100   va_list ap;
3101   va_start (ap, msg);
3102
3103   force_error = do_warning = 1;
3104   issue_warning_error_from_context (cl, msg, ap);
3105   do_warning = force_error = 0;
3106   va_end (ap);
3107 }
3108
3109 static tree
3110 find_expr_with_wfl (tree node)
3111 {
3112   while (node)
3113     {
3114       char code;
3115       tree to_return;
3116
3117       switch (TREE_CODE (node))
3118         {
3119         case BLOCK:
3120           node = BLOCK_EXPR_BODY (node);
3121           continue;
3122
3123         case COMPOUND_EXPR:
3124           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3125           if (to_return)
3126             return to_return;
3127           node = TREE_OPERAND (node, 1);
3128           continue;
3129
3130         case LOOP_EXPR:
3131           node = TREE_OPERAND (node, 0);
3132           continue;
3133
3134         case LABELED_BLOCK_EXPR:
3135           node = TREE_OPERAND (node, 1);
3136           continue;
3137
3138         default:
3139           code = TREE_CODE_CLASS (TREE_CODE (node));
3140           if (((code == '1') || (code == '2') || (code == 'e'))
3141               && EXPR_WFL_LINECOL (node))
3142             return node;
3143           return NULL_TREE;
3144         }
3145     }
3146   return NULL_TREE;
3147 }
3148
3149 /* Issue a missing return statement error. Uses METHOD to figure the
3150    last line of the method the error occurs in.  */
3151
3152 static void
3153 missing_return_error (tree method)
3154 {
3155   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3156   parse_error_context (wfl_operator, "Missing return statement");
3157 }
3158
3159 /* Issue an unreachable statement error. From NODE, find the next
3160    statement to report appropriately.  */
3161 static void
3162 unreachable_stmt_error (tree node)
3163 {
3164   /* Browse node to find the next expression node that has a WFL. Use
3165      the location to report the error */
3166   if (TREE_CODE (node) == COMPOUND_EXPR)
3167     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3168   else
3169     node = find_expr_with_wfl (node);
3170
3171   if (node)
3172     {
3173       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3174       parse_error_context (wfl_operator, "Unreachable statement");
3175     }
3176   else
3177     abort ();
3178 }
3179
3180 static int
3181 not_accessible_field_error (tree wfl, tree decl)
3182 {
3183   parse_error_context
3184     (wfl, "Can't access %s field `%s.%s' from `%s'",
3185      java_accstring_lookup (get_access_flags_from_decl (decl)),
3186      GET_TYPE_NAME (DECL_CONTEXT (decl)),
3187      IDENTIFIER_POINTER (DECL_NAME (decl)),
3188      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3189   return 1;
3190 }
3191
3192 int
3193 java_report_errors (void)
3194 {
3195   if (java_error_count)
3196     fprintf (stderr, "%d error%s",
3197              java_error_count, (java_error_count == 1 ? "" : "s"));
3198   if (java_warning_count)
3199     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3200              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3201   if (java_error_count || java_warning_count)
3202     putc ('\n', stderr);
3203   return java_error_count;
3204 }
3205
3206 static char *
3207 java_accstring_lookup (int flags)
3208 {
3209   static char buffer [80];
3210 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3211
3212   /* Access modifier looked-up first for easier report on forbidden
3213      access. */
3214   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3215   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3216   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3217   if (flags & ACC_STATIC) COPY_RETURN ("static");
3218   if (flags & ACC_FINAL) COPY_RETURN ("final");
3219   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3220   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3221   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3222   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3223   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3224   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3225
3226   buffer [0] = '\0';
3227   return buffer;
3228 #undef COPY_RETURN
3229 }
3230
3231 /* Issuing error messages upon redefinition of classes, interfaces or
3232    variables. */
3233
3234 static void
3235 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3236 {
3237   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3238                        context, IDENTIFIER_POINTER (id),
3239                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3240   /* Here we should point out where its redefined. It's a unicode. FIXME */
3241 }
3242
3243 static void
3244 variable_redefinition_error (tree context, tree name, tree type, int line)
3245 {
3246   const char *type_name;
3247
3248   /* Figure a proper name for type. We might haven't resolved it */
3249   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3250     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3251   else
3252     type_name = lang_printable_name (type, 0);
3253
3254   parse_error_context (context,
3255                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3256                        IDENTIFIER_POINTER (name),
3257                        type_name, IDENTIFIER_POINTER (name), line);
3258 }
3259
3260 /* If ANAME is terminated with `[]', it indicates an array. This
3261    function returns the number of `[]' found and if this number is
3262    greater than zero, it extracts the array type name and places it in
3263    the node pointed to by TRIMMED unless TRIMMED is null.  */
3264
3265 static int
3266 build_type_name_from_array_name (tree aname, tree *trimmed)
3267 {
3268   const char *name = IDENTIFIER_POINTER (aname);
3269   int len = IDENTIFIER_LENGTH (aname);
3270   int array_dims;
3271
3272   STRING_STRIP_BRACKETS (name, len, array_dims);
3273
3274   if (array_dims && trimmed)
3275     *trimmed = get_identifier_with_length (name, len);
3276
3277   return array_dims;
3278 }
3279
3280 static tree
3281 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3282 {
3283   int more_dims = 0;
3284
3285   /* Eventually get more dims */
3286   more_dims = build_type_name_from_array_name (name, &name);
3287
3288   /* If we have, then craft a new type for this variable */
3289   if (more_dims)
3290     {
3291       tree save = type;
3292
3293       /* If we have a pointer, use its type */
3294       if (TREE_CODE (type) == POINTER_TYPE)
3295         type = TREE_TYPE (type);
3296
3297       /* Building the first dimension of a primitive type uses this
3298          function */
3299       if (JPRIMITIVE_TYPE_P (type))
3300         {
3301           type = build_java_array_type (type, -1);
3302           more_dims--;
3303         }
3304       /* Otherwise, if we have a WFL for this type, use it (the type
3305          is already an array on an unresolved type, and we just keep
3306          on adding dimensions) */
3307       else if (type_wfl)
3308         {
3309           type = type_wfl;
3310           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3311                                                         NULL);
3312         }
3313
3314       /* Add all the dimensions */
3315       while (more_dims--)
3316         type = build_unresolved_array_type (type);
3317
3318       /* The type may have been incomplete in the first place */
3319       if (type_wfl)
3320         type = obtain_incomplete_type (type);
3321     }
3322
3323   if (ret_name)
3324     *ret_name = name;
3325   return type;
3326 }
3327
3328 /* Build something that the type identifier resolver will identify as
3329    being an array to an unresolved type. TYPE_WFL is a WFL on a
3330    identifier. */
3331
3332 static tree
3333 build_unresolved_array_type (tree type_or_wfl)
3334 {
3335   const char *ptr;
3336   tree wfl;
3337
3338   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3339      just create a array type */
3340   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3341     return build_java_array_type (type_or_wfl, -1);
3342
3343   obstack_grow (&temporary_obstack,
3344                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3345                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3346   obstack_grow0 (&temporary_obstack, "[]", 2);
3347   ptr = obstack_finish (&temporary_obstack);
3348   wfl = build_expr_wfl (get_identifier (ptr),
3349                         EXPR_WFL_FILENAME (type_or_wfl),
3350                         EXPR_WFL_LINENO (type_or_wfl),
3351                         EXPR_WFL_COLNO (type_or_wfl));
3352   /* Re-install the existing qualifications so that the type can be
3353      resolved properly. */
3354   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3355   return wfl;
3356 }
3357
3358 static void
3359 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3360 {
3361   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3362     parse_error_context (wfl, "Interface `%s' repeated",
3363                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3364 }
3365
3366 /* Bulk of common class/interface checks. Return 1 if an error was
3367    encountered. TAG is 0 for a class, 1 for an interface.  */
3368
3369 static int
3370 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3371                                 tree qualified_name, tree decl, tree cl)
3372 {
3373   tree node;
3374   int sca = 0;                  /* Static class allowed */
3375   int icaf = 0;                 /* Inner class allowed flags */
3376   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3377
3378   if (!quiet_flag)
3379     fprintf (stderr, " %s%s %s",
3380              (CPC_INNER_P () ? "inner" : ""),
3381              (is_interface ? "interface" : "class"),
3382              IDENTIFIER_POINTER (qualified_name));
3383
3384   /* Scope of an interface/class type name:
3385        - Can't be imported by a single type import
3386        - Can't already exists in the package */
3387   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3388       && (node = find_name_in_single_imports (raw_name))
3389       && !CPC_INNER_P ())
3390     {
3391       parse_error_context
3392         (cl, "%s name `%s' clashes with imported type `%s'",
3393          (is_interface ? "Interface" : "Class"),
3394          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3395       return 1;
3396     }
3397   if (decl && CLASS_COMPLETE_P (decl))
3398     {
3399       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3400                                    qualified_name, decl, cl);
3401       return 1;
3402     }
3403
3404   if (check_inner_class_redefinition (raw_name, cl))
3405     return 1;
3406
3407   /* If public, file name should match class/interface name, except
3408      when dealing with an inner class */
3409   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3410     {
3411       const char *f;
3412
3413       for (f = &input_filename [strlen (input_filename)];
3414            f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3415            f--)
3416         ;
3417       if (IS_DIR_SEPARATOR (f[0]))
3418         f++;
3419       if (strncmp (IDENTIFIER_POINTER (raw_name),
3420                    f , IDENTIFIER_LENGTH (raw_name)) ||
3421           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3422         parse_error_context
3423           (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3424                              (is_interface ? "interface" : "class"),
3425                              IDENTIFIER_POINTER (qualified_name),
3426                              IDENTIFIER_POINTER (raw_name));
3427     }
3428
3429   /* Static classes can be declared only in top level classes. Note:
3430      once static, a inner class is a top level class. */
3431   if (flags & ACC_STATIC)
3432     {
3433       /* Catch the specific error of declaring an class inner class
3434          with no toplevel enclosing class. Prevent check_modifiers from
3435          complaining a second time */
3436       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3437         {
3438           parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3439                                IDENTIFIER_POINTER (qualified_name));
3440           sca = ACC_STATIC;
3441         }
3442       /* Else, in the context of a top-level class declaration, let
3443          `check_modifiers' do its job, otherwise, give it a go */
3444       else
3445         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3446     }
3447
3448   /* Inner classes can be declared private or protected
3449      within their enclosing classes. */
3450   if (CPC_INNER_P ())
3451     {
3452       /* A class which is local to a block can't be public, private,
3453          protected or static. But it is created final, so allow this
3454          one. */
3455       if (current_function_decl)
3456         icaf = sca = uaaf = ACC_FINAL;
3457       else
3458         {
3459           check_modifiers_consistency (flags);
3460           icaf = ACC_PROTECTED;
3461           if (! CLASS_INTERFACE (GET_CPC ()))
3462             icaf |= ACC_PRIVATE;
3463         }
3464     }
3465
3466   if (is_interface)
3467     {
3468       if (CPC_INNER_P ())
3469         uaaf = INTERFACE_INNER_MODIFIERS;
3470       else
3471         uaaf = INTERFACE_MODIFIERS;
3472
3473       check_modifiers ("Illegal modifier `%s' for interface declaration",
3474                        flags, uaaf);
3475     }
3476   else
3477     check_modifiers ((current_function_decl ?
3478                       "Illegal modifier `%s' for local class declaration" :
3479                       "Illegal modifier `%s' for class declaration"),
3480                      flags, uaaf|sca|icaf);
3481   return 0;
3482 }
3483
3484 /* Construct a nested class name.  If the final component starts with
3485    a digit, return true.  Otherwise return false.  */
3486 static int
3487 make_nested_class_name (tree cpc_list)
3488 {
3489   tree name;
3490
3491   if (!cpc_list)
3492     return 0;
3493
3494   make_nested_class_name (TREE_CHAIN (cpc_list));
3495
3496   /* Pick the qualified name when dealing with the first upmost
3497      enclosing class */
3498   name = (TREE_CHAIN (cpc_list)
3499           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3500   obstack_grow (&temporary_obstack,
3501                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3502   obstack_1grow (&temporary_obstack, '$');
3503
3504   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3505 }
3506
3507 /* Can't redefine a class already defined in an earlier scope. */
3508
3509 static int
3510 check_inner_class_redefinition (tree raw_name, tree cl)
3511 {
3512   tree scope_list;
3513
3514   for (scope_list = GET_CPC_LIST (); scope_list;
3515        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3516     if (raw_name == GET_CPC_UN_NODE (scope_list))
3517       {
3518         parse_error_context
3519           (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",
3520            IDENTIFIER_POINTER (raw_name));
3521         return 1;
3522       }
3523   return 0;
3524 }
3525
3526 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3527    we remember ENCLOSING and SUPER.  */
3528
3529 static tree
3530 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3531                      tree *super, tree class_type)
3532 {
3533   tree local_enclosing = *enclosing;
3534   tree local_super = NULL_TREE;
3535
3536   while (local_enclosing)
3537     {
3538       tree intermediate, decl;
3539
3540       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3541         local_enclosing;
3542
3543       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3544         return decl;
3545
3546       intermediate = local_enclosing;
3547       /* Explore enclosing contexts. */
3548       while (INNER_CLASS_DECL_P (intermediate))
3549         {
3550           intermediate = DECL_CONTEXT (intermediate);
3551           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3552             return decl;
3553         }
3554
3555       /* Now go to the upper classes, bail out if necessary.  We will
3556          analyze the returned SUPER and act accordingly (see
3557          do_resolve_class).  */
3558       if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3559           || TREE_TYPE (local_enclosing) == void_type_node)
3560         {
3561           parse_error_context (cl, "Qualifier must be a reference");
3562           local_enclosing = NULL_TREE;
3563           break;
3564         }
3565       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3566       if (!local_super || local_super == object_type_node)
3567         break;
3568
3569       if (TREE_CODE (local_super) == POINTER_TYPE)
3570         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3571       else
3572         local_super = TYPE_NAME (local_super);
3573
3574       /* We may not have checked for circular inheritance yet, so do so
3575          here to prevent an infinite loop. */
3576       if (htab_find (circularity_hash, local_super) != NULL)
3577         {
3578           if (!cl)
3579             cl = lookup_cl (local_enclosing);
3580
3581           parse_error_context
3582             (cl, "Cyclic inheritance involving %s",
3583              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3584           local_enclosing = NULL_TREE;
3585         }
3586       else
3587         local_enclosing = local_super;
3588     }
3589
3590   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3591   *super = local_super;
3592   *enclosing = local_enclosing;
3593
3594   return NULL_TREE;
3595 }
3596
3597 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3598    qualified. */
3599
3600 static tree
3601 find_as_inner_class (tree enclosing, tree name, tree cl)
3602 {
3603   tree qual, to_return;
3604   if (!enclosing)
3605     return NULL_TREE;
3606
3607   name = TYPE_NAME (name);
3608
3609   /* First search: within the scope of `enclosing', search for name */
3610   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3611     qual = EXPR_WFL_QUALIFICATION (cl);
3612   else if (cl)
3613     qual = build_tree_list (cl, NULL_TREE);
3614   else
3615     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3616
3617   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3618     return to_return;
3619
3620   /* We're dealing with a qualified name. Try to resolve thing until
3621      we get something that is an enclosing class. */
3622   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3623     {
3624       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3625
3626       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3627            qual = TREE_CHAIN (qual))
3628         {
3629           acc = merge_qualified_name (acc,
3630                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3631           BUILD_PTR_FROM_NAME (ptr, acc);
3632           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3633         }
3634
3635       /* A NULL qual and a decl means that the search ended
3636          successfully?!? We have to do something then. FIXME */
3637
3638       if (decl)
3639         enclosing = decl;
3640       else
3641         qual = EXPR_WFL_QUALIFICATION (cl);
3642     }
3643   /* Otherwise, create a qual for the other part of the resolution. */
3644   else
3645     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3646
3647   return find_as_inner_class_do (qual, enclosing);
3648 }
3649
3650 /* We go inside the list of sub classes and try to find a way
3651    through. */
3652
3653 static tree
3654 find_as_inner_class_do (tree qual, tree enclosing)
3655 {
3656   if (!qual)
3657     return NULL_TREE;
3658
3659   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3660     {
3661       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3662       tree next_enclosing = NULL_TREE;
3663       tree inner_list;
3664
3665       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3666            inner_list; inner_list = TREE_CHAIN (inner_list))
3667         {
3668           if (TREE_VALUE (inner_list) == name_to_match)
3669             {
3670               next_enclosing = TREE_PURPOSE (inner_list);
3671               break;
3672             }
3673         }
3674       enclosing = next_enclosing;
3675     }
3676
3677   return (!qual && enclosing ? enclosing : NULL_TREE);
3678 }
3679
3680 /* Reach all inner classes and tie their unqualified name to a
3681    DECL. */
3682
3683 static void
3684 set_nested_class_simple_name_value (tree outer, int set)
3685 {
3686   tree l;
3687
3688   for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
3689     IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
3690                                                 TREE_PURPOSE (l) : NULL_TREE);
3691 }
3692
3693 static void
3694 link_nested_class_to_enclosing (void)
3695 {
3696   if (GET_ENCLOSING_CPC ())
3697     {
3698       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3699       DECL_INNER_CLASS_LIST (enclosing) =
3700         tree_cons (GET_CPC (), GET_CPC_UN (),
3701                    DECL_INNER_CLASS_LIST (enclosing));
3702     }
3703 }
3704
3705 static tree
3706 maybe_make_nested_class_name (tree name)
3707 {
3708   tree id = NULL_TREE;
3709
3710   if (CPC_INNER_P ())
3711     {
3712       /* If we're in a function, we must append a number to create the
3713          nested class name.  However, we don't do this if the class we
3714          are constructing is anonymous, because in that case we'll
3715          already have a number as the class name.  */
3716       if (! make_nested_class_name (GET_CPC_LIST ())
3717           && current_function_decl != NULL_TREE
3718           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3719         {
3720           char buf[10];
3721           sprintf (buf, "%d", anonymous_class_counter);
3722           ++anonymous_class_counter;
3723           obstack_grow (&temporary_obstack, buf, strlen (buf));
3724           obstack_1grow (&temporary_obstack, '$');
3725         }
3726       obstack_grow0 (&temporary_obstack,
3727                      IDENTIFIER_POINTER (name),
3728                      IDENTIFIER_LENGTH (name));
3729       id = get_identifier (obstack_finish (&temporary_obstack));
3730       if (ctxp->package)
3731         QUALIFIED_P (id) = 1;
3732     }
3733   return id;
3734 }
3735
3736 /* If DECL is NULL, create and push a new DECL, record the current
3737    line CL and do other maintenance things.  */
3738
3739 static tree
3740 maybe_create_class_interface_decl (tree decl, tree raw_name,
3741                                    tree qualified_name, tree cl)
3742 {
3743   if (!decl)
3744     decl = push_class (make_class (), qualified_name);
3745
3746   /* Take care of the file and line business */
3747   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3748   /* If we're emitting xrefs, store the line/col number information */
3749   if (flag_emit_xref)
3750     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3751   else
3752     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3753   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3754   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3755   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3756     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3757
3758   PUSH_CPC (decl, raw_name);
3759   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3760
3761   /* Link the declaration to the already seen ones */
3762   TREE_CHAIN (decl) = ctxp->class_list;
3763   ctxp->class_list = decl;
3764
3765   /* Create a new nodes in the global lists */
3766   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3767   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3768
3769   /* Install a new dependency list element */
3770   create_jdep_list (ctxp);
3771
3772   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3773                           IDENTIFIER_POINTER (qualified_name)));
3774   return decl;
3775 }
3776
3777 static void
3778 add_superinterfaces (tree decl, tree interface_list)
3779 {
3780   tree node;
3781   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3782      takes care of ensuring that:
3783        - This is an accessible interface type,
3784        - Circularity detection.
3785    parser_add_interface is then called. If present but not defined,
3786    the check operation is delayed until the super interface gets
3787    defined.  */
3788   for (node = interface_list; node; node = TREE_CHAIN (node))
3789     {
3790       tree current = TREE_PURPOSE (node);
3791       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3792       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3793         {
3794           if (!parser_check_super_interface (idecl, decl, current))
3795             parser_add_interface (decl, idecl, current);
3796         }
3797       else
3798         register_incomplete_type (JDEP_INTERFACE,
3799                                   current, decl, NULL_TREE);
3800     }
3801 }
3802
3803 /* Create an interface in pass1 and return its decl. Return the
3804    interface's decl in pass 2.  */
3805
3806 static tree
3807 create_interface (int flags, tree id, tree super)
3808 {
3809   tree raw_name = EXPR_WFL_NODE (id);
3810   tree q_name = parser_qualified_classname (raw_name);
3811   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3812
3813   /* Certain syntax errors are making SUPER be like ID. Avoid this
3814      case. */
3815   if (ctxp->class_err && id == super)
3816     super = NULL;
3817
3818   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3819
3820   /* Basic checks: scope, redefinition, modifiers */
3821   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3822     {
3823       PUSH_ERROR ();
3824       return NULL_TREE;
3825     }
3826
3827   /* Suspend the current parsing context if we're parsing an inner
3828      interface */
3829   if (CPC_INNER_P ())
3830     {
3831       java_parser_context_suspend ();
3832       /* Interface members are public. */
3833       if (CLASS_INTERFACE (GET_CPC ()))
3834         flags |= ACC_PUBLIC;
3835     }
3836
3837   /* Push a new context for (static) initialized upon declaration fields */
3838   java_parser_context_push_initialized_field ();
3839
3840   /* Interface modifiers check
3841        - public/abstract allowed (already done at that point)
3842        - abstract is obsolete (comes first, it's a warning, or should be)
3843        - Can't use twice the same (checked in the modifier rule) */
3844   if ((flags & ACC_ABSTRACT) && flag_redundant)
3845     parse_warning_context
3846       (MODIFIER_WFL (ABSTRACT_TK),
3847        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3848
3849   /* Create a new decl if DECL is NULL, otherwise fix it */
3850   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3851
3852   /* Set super info and mark the class a complete */
3853   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3854                   object_type_node, ctxp->interface_number);
3855   ctxp->interface_number = 0;
3856   CLASS_COMPLETE_P (decl) = 1;
3857   add_superinterfaces (decl, super);
3858
3859   /* Eventually sets the @deprecated tag flag */
3860   CHECK_DEPRECATED (decl);
3861
3862   return decl;
3863 }
3864
3865 /* Patch anonymous class CLASS, by either extending or implementing
3866    DEP.  */
3867
3868 static void
3869 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
3870 {
3871   tree class = TREE_TYPE (class_decl);
3872   tree type =  TREE_TYPE (type_decl);
3873   tree binfo = TYPE_BINFO (class);
3874
3875   /* If it's an interface, implement it */
3876   if (CLASS_INTERFACE (type_decl))
3877     {
3878       tree s_binfo;
3879       int length;
3880
3881       if (parser_check_super_interface (type_decl, class_decl, wfl))
3882         return;
3883
3884       s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3885       length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3886       TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3887       TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3888       /* And add the interface */
3889       parser_add_interface (class_decl, type_decl, wfl);
3890     }
3891   /* Otherwise, it's a type we want to extend */
3892   else
3893     {
3894       if (parser_check_super (type_decl, class_decl, wfl))
3895         return;
3896       BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3897     }
3898 }
3899
3900 static tree
3901 create_anonymous_class (int location, tree type_name)
3902 {
3903   char buffer [80];
3904   tree super = NULL_TREE, itf = NULL_TREE;
3905   tree id, type_decl, class;
3906
3907   /* The unqualified name of the anonymous class. It's just a number. */
3908   sprintf (buffer, "%d", anonymous_class_counter++);
3909   id = build_wfl_node (get_identifier (buffer));
3910   EXPR_WFL_LINECOL (id) = location;
3911
3912   /* We know about the type to extend/implement. We go ahead */
3913   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3914     {
3915       /* Create a class which either implements on extends the designated
3916          class. The class bears an inaccessible name. */
3917       if (CLASS_INTERFACE (type_decl))
3918         {
3919           /* It's OK to modify it here. It's been already used and
3920              shouldn't be reused */
3921           ctxp->interface_number = 1;
3922           /* Interfaces should presented as a list of WFLs */
3923           itf = build_tree_list (type_name, NULL_TREE);
3924         }
3925       else
3926         super = type_name;
3927     }
3928
3929   class = create_class (ACC_FINAL, id, super, itf);
3930
3931   /* We didn't know anything about the stuff. We register a dependence. */
3932   if (!type_decl)
3933     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3934
3935   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3936   return class;
3937 }
3938
3939 /* Create a class in pass1 and return its decl. Return class
3940    interface's decl in pass 2.  */
3941
3942 static tree
3943 create_class (int flags, tree id, tree super, tree interfaces)
3944 {
3945   tree raw_name = EXPR_WFL_NODE (id);
3946   tree class_id, decl;
3947   tree super_decl_type;
3948
3949   /* Certain syntax errors are making SUPER be like ID. Avoid this
3950      case. */
3951   if (ctxp->class_err && id == super)
3952     super = NULL;
3953
3954   class_id = parser_qualified_classname (raw_name);
3955   decl = IDENTIFIER_CLASS_VALUE (class_id);
3956   EXPR_WFL_NODE (id) = class_id;
3957
3958   /* Basic check: scope, redefinition, modifiers */
3959   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3960     {
3961       PUSH_ERROR ();
3962       return NULL_TREE;
3963     }
3964
3965   /* Suspend the current parsing context if we're parsing an inner
3966      class or an anonymous class. */
3967   if (CPC_INNER_P ())
3968     {
3969       java_parser_context_suspend ();
3970       /* Interface members are public. */
3971       if (CLASS_INTERFACE (GET_CPC ()))
3972         flags |= ACC_PUBLIC;
3973     }
3974
3975   /* Push a new context for (static) initialized upon declaration fields */
3976   java_parser_context_push_initialized_field ();
3977
3978   /* Class modifier check:
3979        - Allowed modifier (already done at that point)
3980        - abstract AND final forbidden
3981        - Public classes defined in the correct file */
3982   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
3983     parse_error_context
3984       (id, "Class `%s' can't be declared both abstract and final",
3985        IDENTIFIER_POINTER (raw_name));
3986
3987   /* Create a new decl if DECL is NULL, otherwise fix it */
3988   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
3989
3990   /* If SUPER exists, use it, otherwise use Object */
3991   if (super)
3992     {
3993       /* Can't extend java.lang.Object */
3994       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
3995         {
3996           parse_error_context (id, "Can't extend `java.lang.Object'");
3997           return NULL_TREE;
3998         }
3999
4000       super_decl_type =
4001         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4002     }
4003   else if (TREE_TYPE (decl) != object_type_node)
4004     super_decl_type = object_type_node;
4005   /* We're defining java.lang.Object */
4006   else
4007     super_decl_type = NULL_TREE;
4008
4009   /* A class nested in an interface is implicitly static. */
4010   if (INNER_CLASS_DECL_P (decl)
4011       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4012     {
4013       flags |= ACC_STATIC;
4014     }
4015
4016   /* Set super info and mark the class as complete. */
4017   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4018                   ctxp->interface_number);
4019   ctxp->interface_number = 0;
4020   CLASS_COMPLETE_P (decl) = 1;
4021   add_superinterfaces (decl, interfaces);
4022
4023   /* Add the private this$<n> field, Replicate final locals still in
4024      scope as private final fields mangled like val$<local_name>.
4025      This doesn't not occur for top level (static) inner classes. */
4026   if (PURE_INNER_CLASS_DECL_P (decl))
4027     add_inner_class_fields (decl, current_function_decl);
4028
4029   /* If doing xref, store the location at which the inherited class
4030      (if any) was seen. */
4031   if (flag_emit_xref && super)
4032     DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4033
4034   /* Eventually sets the @deprecated tag flag */
4035   CHECK_DEPRECATED (decl);
4036
4037   /* Reset the anonymous class counter when declaring non inner classes */
4038   if (!INNER_CLASS_DECL_P (decl))
4039     anonymous_class_counter = 1;
4040
4041   return decl;
4042 }
4043
4044 /* End a class declaration: register the statements used to create
4045    finit$ and <clinit>, pop the current class and resume the prior
4046    parser context if necessary.  */
4047
4048 static void
4049 end_class_declaration (int resume)
4050 {
4051   /* If an error occurred, context weren't pushed and won't need to be
4052      popped by a resume. */
4053   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4054
4055   if (GET_CPC () != error_mark_node)
4056     dump_java_tree (TDI_class, GET_CPC ());
4057
4058   java_parser_context_pop_initialized_field ();
4059   POP_CPC ();
4060   if (resume && no_error_occurred)
4061     java_parser_context_resume ();
4062
4063   /* We're ending a class declaration, this is a good time to reset
4064      the interface cout. Note that might have been already done in
4065      create_interface, but if at that time an inner class was being
4066      dealt with, the interface count was reset in a context created
4067      for the sake of handling inner classes declaration. */
4068   ctxp->interface_number = 0;
4069 }
4070
4071 static void
4072 add_inner_class_fields (tree class_decl, tree fct_decl)
4073 {
4074   tree block, marker, f;
4075
4076   f = add_field (TREE_TYPE (class_decl),
4077                  build_current_thisn (TREE_TYPE (class_decl)),
4078                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4079                  ACC_PRIVATE);
4080   FIELD_THISN (f) = 1;
4081
4082   if (!fct_decl)
4083     return;
4084
4085   for (block = GET_CURRENT_BLOCK (fct_decl);
4086        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4087     {
4088       tree decl;
4089       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4090         {
4091           tree name, pname;
4092           tree wfl, init, list;
4093
4094           /* Avoid non final arguments. */
4095           if (!LOCAL_FINAL_P (decl))
4096             continue;
4097
4098           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4099           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4100           wfl = build_wfl_node (name);
4101           init = build_wfl_node (pname);
4102           /* Build an initialization for the field: it will be
4103              initialized by a parameter added to finit$, bearing a
4104              mangled name of the field itself (param$<n>.) The
4105              parameter is provided to finit$ by the constructor
4106              invoking it (hence the constructor will also feature a
4107              hidden parameter, set to the value of the outer context
4108              local at the time the inner class is created.)
4109
4110              Note: we take into account all possible locals that can
4111              be accessed by the inner class. It's actually not trivial
4112              to minimize these aliases down to the ones really
4113              used. One way to do that would be to expand all regular
4114              methods first, then finit$ to get a picture of what's
4115              used.  It works with the exception that we would have to
4116              go back on all constructor invoked in regular methods to
4117              have their invocation reworked (to include the right amount
4118              of alias initializer parameters.)
4119
4120              The only real way around, I think, is a first pass to
4121              identify locals really used in the inner class. We leave
4122              the flag FIELD_LOCAL_ALIAS_USED around for that future
4123              use.
4124
4125              On the other hand, it only affect local inner classes,
4126              whose constructors (and finit$ call) will be featuring
4127              unnecessary arguments. It's easy for a developer to keep
4128              this number of parameter down by using the `final'
4129              keyword only when necessary. For the time being, we can
4130              issue a warning on unnecessary finals. FIXME */
4131           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4132                                    wfl, init);
4133
4134           /* Register the field. The TREE_LIST holding the part
4135              initialized/initializer will be marked ARG_FINAL_P so
4136              that the created field can be marked
4137              FIELD_LOCAL_ALIAS. */
4138           list = build_tree_list (wfl, init);
4139           ARG_FINAL_P (list) = 1;
4140           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4141         }
4142     }
4143
4144   if (!CPC_INITIALIZER_STMT (ctxp))
4145     return;
4146
4147   /* If we ever registered an alias field, insert and marker to
4148      remember where the list ends. The second part of the list (the one
4149      featuring initialized fields) so it can be later reversed to
4150      enforce 8.5. The marker will be removed during that operation. */
4151   marker = build_tree_list (NULL_TREE, NULL_TREE);
4152   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4153   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4154 }
4155
4156 /* Can't use lookup_field () since we don't want to load the class and
4157    can't set the CLASS_LOADED_P flag */
4158
4159 static tree
4160 find_field (tree class, tree name)
4161 {
4162   tree decl;
4163   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4164     {
4165       if (DECL_NAME (decl) == name)
4166         return decl;
4167     }
4168   return NULL_TREE;
4169 }
4170
4171 /* Wrap around lookup_field that doesn't potentially upset the value
4172    of CLASS */
4173
4174 static tree
4175 lookup_field_wrapper (tree class, tree name)
4176 {
4177   tree type = class;
4178   tree decl = NULL_TREE;
4179   java_parser_context_save_global ();
4180
4181   /* Last chance: if we're within the context of an inner class, we
4182      might be trying to access a local variable defined in an outer
4183      context. We try to look for it now. */
4184   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4185     {
4186       tree new_name;
4187       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4188       decl = lookup_field (&type, new_name);
4189       if (decl && decl != error_mark_node)
4190         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4191     }
4192   if (!decl || decl == error_mark_node)
4193     {
4194       type = class;
4195       decl = lookup_field (&type, name);
4196     }
4197
4198   /* If the field still hasn't been found, try the next enclosing context. */
4199   if (!decl && INNER_CLASS_TYPE_P (class))
4200     {
4201       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4202       decl = lookup_field_wrapper (outer_type, name);
4203     }
4204
4205   java_parser_context_restore_global ();
4206   return decl == error_mark_node ? NULL : decl;
4207 }
4208
4209 /* Find duplicate field within the same class declarations and report
4210    the error. Returns 1 if a duplicated field was found, 0
4211    otherwise.  */
4212
4213 static int
4214 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4215 {
4216   /* This might be modified to work with method decl as well */
4217   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4218   if (decl)
4219     {
4220       char *t1 = xstrdup (purify_type_name
4221                          ((TREE_CODE (new_type) == POINTER_TYPE
4222                            && TREE_TYPE (new_type) == NULL_TREE) ?
4223                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4224                           lang_printable_name (new_type, 1)));
4225       /* The type may not have been completed by the time we report
4226          the error */
4227       char *t2 = xstrdup (purify_type_name
4228                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4229                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4230                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4231                           lang_printable_name (TREE_TYPE (decl), 1)));
4232       parse_error_context
4233         (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4234          t1, IDENTIFIER_POINTER (new_field_name),
4235          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4236          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4237       free (t1);
4238       free (t2);
4239       return 1;
4240     }
4241   return 0;
4242 }
4243
4244 /* Field registration routine. If TYPE doesn't exist, field
4245    declarations are linked to the undefined TYPE dependency list, to
4246    be later resolved in java_complete_class () */
4247
4248 static void
4249 register_fields (int flags, tree type, tree variable_list)
4250 {
4251   tree current, saved_type;
4252   tree class_type = NULL_TREE;
4253   int saved_lineno = input_line;
4254   int must_chain = 0;
4255   tree wfl = NULL_TREE;
4256
4257   if (GET_CPC ())
4258     class_type = TREE_TYPE (GET_CPC ());
4259
4260   if (!class_type || class_type == error_mark_node)
4261     return;
4262
4263   /* If we're adding fields to interfaces, those fields are public,
4264      static, final */
4265   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4266     {
4267       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4268                                  flags, ACC_PUBLIC, "interface field(s)");
4269       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4270                                  flags, ACC_STATIC, "interface field(s)");
4271       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4272                                  flags, ACC_FINAL, "interface field(s)");
4273       check_modifiers ("Illegal interface member modifier `%s'", flags,
4274                        INTERFACE_FIELD_MODIFIERS);
4275       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4276     }
4277
4278   /* Obtain a suitable type for resolution, if necessary */
4279   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4280
4281   /* If TYPE is fully resolved and we don't have a reference, make one */
4282   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4283
4284   for (current = variable_list, saved_type = type; current;
4285        current = TREE_CHAIN (current), type = saved_type)
4286     {
4287       tree real_type;
4288       tree field_decl;
4289       tree cl = TREE_PURPOSE (current);
4290       tree init = TREE_VALUE (current);
4291       tree current_name = EXPR_WFL_NODE (cl);
4292
4293       /* Can't declare non-final static fields in inner classes */
4294       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4295           && !(flags & ACC_FINAL))
4296         parse_error_context
4297           (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4298            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4299            lang_printable_name (class_type, 0));
4300
4301       /* Process NAME, as it may specify extra dimension(s) for it */
4302       type = build_array_from_name (type, wfl, current_name, &current_name);
4303
4304       /* Type adjustment. We may have just readjusted TYPE because
4305          the variable specified more dimensions. Make sure we have
4306          a reference if we can and don't have one already. Also
4307          change the name if we have an init. */
4308       if (type != saved_type)
4309         {
4310           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4311           if (init)
4312             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4313         }
4314
4315       real_type = GET_REAL_TYPE (type);
4316       /* Check for redeclarations */
4317       if (duplicate_declaration_error_p (current_name, real_type, cl))
4318         continue;
4319
4320       /* Set lineno to the line the field was found and create a
4321          declaration for it. Eventually sets the @deprecated tag flag. */
4322       if (flag_emit_xref)
4323         input_line = EXPR_WFL_LINECOL (cl);
4324       else
4325         input_line = EXPR_WFL_LINENO (cl);
4326       field_decl = add_field (class_type, current_name, real_type, flags);
4327       CHECK_DEPRECATED_NO_RESET (field_decl);
4328
4329       /* If the field denotes a final instance variable, then we
4330          allocate a LANG_DECL_SPECIFIC part to keep track of its
4331          initialization. We also mark whether the field was
4332          initialized upon its declaration. We don't do that if the
4333          created field is an alias to a final local. */
4334       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4335         {
4336           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4337           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4338         }
4339
4340       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4341          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4342          hide parameters to this inner class finit$ and
4343          constructors. It also means that the field isn't final per
4344          say. */
4345       if (ARG_FINAL_P (current))
4346         {
4347           FIELD_LOCAL_ALIAS (field_decl) = 1;
4348           FIELD_FINAL (field_decl) = 0;
4349         }
4350
4351       /* Check if we must chain. */
4352       if (must_chain)
4353         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4354
4355       /* If we have an initialization value tied to the field */
4356       if (init)
4357         {
4358           /* The field is declared static */
4359           if (flags & ACC_STATIC)
4360             {
4361               /* We include the field and its initialization part into
4362                  a list used to generate <clinit>. After <clinit> is
4363                  walked, field initializations will be processed and
4364                  fields initialized with known constants will be taken
4365                  out of <clinit> and have their DECL_INITIAL set
4366                  appropriately. */
4367               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4368               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4369               if (TREE_OPERAND (init, 1)
4370                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4371                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4372             }
4373           /* A non-static field declared with an immediate initialization is
4374              to be initialized in <init>, if any.  This field is remembered
4375              to be processed at the time of the generation of <init>. */
4376           else
4377             {
4378               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4379               SET_CPC_INITIALIZER_STMT (ctxp, init);
4380             }
4381           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4382           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4383         }
4384     }
4385
4386   CLEAR_DEPRECATED;
4387   input_line = saved_lineno;
4388 }
4389
4390 /* Generate finit$, using the list of initialized fields to populate
4391    its body. finit$'s parameter(s) list is adjusted to include the
4392    one(s) used to initialized the field(s) caching outer context
4393    local(s).  */
4394
4395 static tree
4396 generate_finit (tree class_type)
4397 {
4398   int count = 0;
4399   tree list = TYPE_FINIT_STMT_LIST (class_type);
4400   tree mdecl, current, parms;
4401
4402   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4403                                                   class_type, NULL_TREE,
4404                                                   &count);
4405   CRAFTED_PARAM_LIST_FIXUP (parms);
4406   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4407                                     finit_identifier_node, parms);
4408   fix_method_argument_names (parms, mdecl);
4409   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4410                        mdecl, NULL_TREE);
4411   DECL_FUNCTION_NAP (mdecl) = count;
4412   start_artificial_method_body (mdecl);
4413
4414   for (current = list; current; current = TREE_CHAIN (current))
4415     java_method_add_stmt (mdecl,
4416                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4417                                                 current));
4418   end_artificial_method_body (mdecl);
4419   return mdecl;
4420 }
4421
4422 /* Generate a function to run the instance initialization code. The
4423    private method is called `instinit$'. Unless we're dealing with an
4424    anonymous class, we determine whether all ctors of CLASS_TYPE
4425    declare a checked exception in their `throws' clause in order to
4426    see whether it's necessary to encapsulate the instance initializer
4427    statements in a try/catch/rethrow sequence.  */
4428
4429 static tree
4430 generate_instinit (tree class_type)
4431 {
4432   tree current;
4433   tree compound = NULL_TREE;
4434   tree parms = tree_cons (this_identifier_node,
4435                           build_pointer_type (class_type), end_params_node);
4436   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4437                                          void_type_node,
4438                                          instinit_identifier_node, parms);
4439
4440   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4441                        mdecl, NULL_TREE);
4442
4443   /* Gather all the statements in a compound */
4444   for (current = TYPE_II_STMT_LIST (class_type);
4445        current; current = TREE_CHAIN (current))
4446     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4447
4448   /* We need to encapsulate COMPOUND by a try/catch statement to
4449      rethrow exceptions that might occur in the instance initializer.
4450      We do that only if all ctors of CLASS_TYPE are set to catch a
4451      checked exception. This doesn't apply to anonymous classes (since
4452      they don't have declared ctors.) */
4453   if (!ANONYMOUS_CLASS_P (class_type) &&
4454       ctors_unchecked_throws_clause_p (class_type))
4455     {
4456       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4457                                              build1 (THROW_EXPR, NULL_TREE,
4458                                                      build_wfl_node (wpv_id)));
4459       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4460                                                       exception_type_node);
4461     }
4462
4463   start_artificial_method_body (mdecl);
4464   java_method_add_stmt (mdecl, compound);
4465   end_artificial_method_body (mdecl);
4466
4467   return mdecl;
4468 }
4469
4470 /* FIXME */
4471 static tree
4472 build_instinit_invocation (tree class_type)
4473 {
4474   tree to_return = NULL_TREE;
4475
4476   if (TYPE_II_STMT_LIST (class_type))
4477     {
4478       tree parm = build_tree_list (NULL_TREE,
4479                                    build_wfl_node (this_identifier_node));
4480       to_return =
4481         build_method_invocation (build_wfl_node (instinit_identifier_node),
4482                                  parm);
4483     }
4484   return to_return;
4485 }
4486
4487 /* Shared across method_declarator and method_header to remember the
4488    patch stage that was reached during the declaration of the method.
4489    A method DECL is built differently is there is no patch
4490    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4491    pending on the currently defined method.  */
4492
4493 static int patch_stage;
4494
4495 /* Check the method declaration and add the method to its current
4496    class.  If the argument list is known to contain incomplete types,
4497    the method is partially added and the registration will be resume
4498    once the method arguments resolved. If TYPE is NULL, we're dealing
4499    with a constructor.  */
4500
4501 static tree
4502 method_header (int flags, tree type, tree mdecl, tree throws)
4503 {
4504   tree type_wfl = NULL_TREE;
4505   tree meth_name = NULL_TREE;
4506   tree current, orig_arg, this_class = NULL;
4507   tree id, meth;
4508   int saved_lineno;
4509   int constructor_ok = 0, must_chain;
4510   int count;
4511
4512   if (mdecl == error_mark_node)
4513     return error_mark_node;
4514   meth = TREE_VALUE (mdecl);
4515   id = TREE_PURPOSE (mdecl);
4516
4517   check_modifiers_consistency (flags);
4518
4519   if (GET_CPC ())
4520     this_class = TREE_TYPE (GET_CPC ());
4521
4522   if (!this_class || this_class == error_mark_node)
4523     return NULL_TREE;
4524
4525   /* There are some forbidden modifiers for an abstract method and its
4526      class must be abstract as well.  */
4527   if (type && (flags & ACC_ABSTRACT))
4528     {
4529       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4530       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4531       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4532       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4533       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4534       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4535       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4536           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4537         parse_error_context
4538           (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4539            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4540            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4541     }
4542
4543   /* A native method can't be strictfp.  */
4544   if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4545     parse_error_context (id, "native method `%s' can't be strictfp",
4546                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4547   /* No such thing as a transient or volatile method.  */
4548   if ((flags & ACC_TRANSIENT))
4549     parse_error_context (id, "method `%s' can't be transient",
4550                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4551   if ((flags & ACC_VOLATILE))
4552     parse_error_context (id, "method `%s' can't be volatile",
4553                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4554
4555   /* Things to be checked when declaring a constructor */
4556   if (!type)
4557     {
4558       int ec = java_error_count;
4559       /* 8.6: Constructor declarations: we might be trying to define a
4560          method without specifying a return type. */
4561       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4562         parse_error_context
4563           (id, "Invalid method declaration, return type required");
4564       /* 8.6.3: Constructor modifiers */
4565       else
4566         {
4567           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4568           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4569           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4570           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4571           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4572           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4573         }
4574       /* If we found error here, we don't consider it's OK to tread
4575          the method definition as a constructor, for the rest of this
4576          function */
4577       if (ec == java_error_count)
4578         constructor_ok = 1;
4579     }
4580
4581   /* Method declared within the scope of an interface are implicitly
4582      abstract and public. Conflicts with other erroneously provided
4583      modifiers are checked right after. */
4584
4585   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4586     {
4587       /* If FLAGS isn't set because of a modifier, turn the
4588          corresponding modifier WFL to NULL so we issue a warning on
4589          the obsolete use of the modifier */
4590       if (!(flags & ACC_PUBLIC))
4591         MODIFIER_WFL (PUBLIC_TK) = NULL;
4592       if (!(flags & ACC_ABSTRACT))
4593         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4594       flags |= ACC_PUBLIC;
4595       flags |= ACC_ABSTRACT;
4596     }
4597
4598   /* Inner class can't declare static methods */
4599   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4600     {
4601       parse_error_context
4602         (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4603          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4604          lang_printable_name (this_class, 0));
4605     }
4606
4607   /* Modifiers context reset moved up, so abstract method declaration
4608      modifiers can be later checked.  */
4609
4610   /* Set constructor returned type to void and method name to <init>,
4611      unless we found an error identifier the constructor (in which
4612      case we retain the original name) */
4613   if (!type)
4614     {
4615       type = void_type_node;
4616       if (constructor_ok)
4617         meth_name = init_identifier_node;
4618     }
4619   else
4620     meth_name = EXPR_WFL_NODE (id);
4621
4622   /* Do the returned type resolution and registration if necessary */
4623   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4624
4625   if (meth_name)
4626     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4627   EXPR_WFL_NODE (id) = meth_name;
4628   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4629
4630   if (must_chain)
4631     {
4632       patch_stage = JDEP_METHOD_RETURN;
4633       register_incomplete_type (patch_stage, type_wfl, id, type);
4634       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4635     }
4636   else
4637     TREE_TYPE (meth) = type;
4638
4639   saved_lineno = input_line;
4640   /* When defining an abstract or interface method, the curly
4641      bracket at level 1 doesn't exist because there is no function
4642      body */
4643   input_line = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4644             EXPR_WFL_LINENO (id));
4645
4646   /* Remember the original argument list */
4647   orig_arg = TYPE_ARG_TYPES (meth);
4648
4649   if (patch_stage)              /* includes ret type and/or all args */
4650     {
4651       jdep *jdep;
4652       meth = add_method_1 (this_class, flags, meth_name, meth);
4653       /* Patch for the return type */
4654       if (patch_stage == JDEP_METHOD_RETURN)
4655         {
4656           jdep = CLASSD_LAST (ctxp->classd_list);
4657           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4658         }
4659       /* This is the stop JDEP. METH allows the function's signature
4660          to be computed. */
4661       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4662     }
4663   else
4664     meth = add_method (this_class, flags, meth_name,
4665                        build_java_signature (meth));
4666
4667   /* Remember final parameters */
4668   MARK_FINAL_PARMS (meth, orig_arg);
4669
4670   /* Fix the method argument list so we have the argument name
4671      information */
4672   fix_method_argument_names (orig_arg, meth);
4673
4674   /* Register the parameter number and re-install the current line
4675      number */
4676   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4677   input_line = saved_lineno;
4678
4679   /* Register exception specified by the `throws' keyword for
4680      resolution and set the method decl appropriate field to the list.
4681      Note: the grammar ensures that what we get here are class
4682      types. */
4683   if (throws)
4684     {
4685       throws = nreverse (throws);
4686       for (current = throws; current; current = TREE_CHAIN (current))
4687         {
4688           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4689                                     NULL_TREE, NULL_TREE);
4690           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4691             &TREE_VALUE (current);
4692         }
4693       DECL_FUNCTION_THROWS (meth) = throws;
4694     }
4695
4696   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4697     DECL_FUNCTION_WFL (meth) = id;
4698
4699   /* Set the flag if we correctly processed a constructor */
4700   if (constructor_ok)
4701     {
4702       DECL_CONSTRUCTOR_P (meth) = 1;
4703       /* Compute and store the number of artificial parameters declared
4704          for this constructor */
4705       for (count = 0, current = TYPE_FIELDS (this_class); current;
4706            current = TREE_CHAIN (current))
4707         if (FIELD_LOCAL_ALIAS (current))
4708           count++;
4709       DECL_FUNCTION_NAP (meth) = count;
4710     }
4711
4712   /* Eventually set the @deprecated tag flag */
4713   CHECK_DEPRECATED (meth);
4714
4715   /* If doing xref, store column and line number information instead
4716      of the line number only. */
4717   if (flag_emit_xref)
4718     DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4719
4720   return meth;
4721 }
4722
4723 static void
4724 fix_method_argument_names (tree orig_arg, tree meth)
4725 {
4726   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4727   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4728     {
4729       TREE_PURPOSE (arg) = this_identifier_node;
4730       arg = TREE_CHAIN (arg);
4731     }
4732   while (orig_arg != end_params_node)
4733     {
4734       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4735       orig_arg = TREE_CHAIN (orig_arg);
4736       arg = TREE_CHAIN (arg);
4737     }
4738 }
4739
4740 /* Complete the method declaration with METHOD_BODY.  */
4741
4742 static void
4743 finish_method_declaration (tree method_body)
4744 {
4745   int flags;
4746
4747   if (!current_function_decl)
4748     return;
4749
4750   flags = get_access_flags_from_decl (current_function_decl);
4751
4752   /* 8.4.5 Method Body */
4753   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4754     {
4755       tree name = DECL_NAME (current_function_decl);
4756       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4757                            "%s method `%s' can't have a body defined",
4758                            (METHOD_NATIVE (current_function_decl) ?
4759                             "Native" : "Abstract"),
4760                            IDENTIFIER_POINTER (name));
4761       method_body = NULL_TREE;
4762     }
4763   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4764     {
4765       tree name = DECL_NAME (current_function_decl);
4766       parse_error_context
4767         (DECL_FUNCTION_WFL (current_function_decl),
4768          "Non native and non abstract method `%s' must have a body defined",
4769          IDENTIFIER_POINTER (name));
4770       method_body = NULL_TREE;
4771     }
4772
4773   if (flag_emit_class_files && method_body
4774       && TREE_CODE (method_body) == NOP_EXPR
4775       && TREE_TYPE (current_function_decl)
4776       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4777     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4778
4779   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4780   maybe_absorb_scoping_blocks ();
4781   /* Exit function's body */
4782   exit_block ();
4783   /* Merge last line of the function with first line, directly in the
4784      function decl. It will be used to emit correct debug info. */
4785   if (!flag_emit_xref)
4786     DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4787
4788   /* Since function's argument's list are shared, reset the
4789      ARG_FINAL_P parameter that might have been set on some of this
4790      function parameters. */
4791   UNMARK_FINAL_PARMS (current_function_decl);
4792
4793   /* So we don't have an irrelevant function declaration context for
4794      the next static block we'll see. */
4795   current_function_decl = NULL_TREE;
4796 }
4797
4798 /* Build a an error message for constructor circularity errors.  */
4799
4800 static char *
4801 constructor_circularity_msg (tree from, tree to)
4802 {
4803   static char string [4096];
4804   char *t = xstrdup (lang_printable_name (from, 0));
4805   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4806   free (t);
4807   return string;
4808 }
4809
4810 /* Verify a circular call to METH. Return 1 if an error is found, 0
4811    otherwise.  */
4812
4813 static GTY(()) tree vcc_list;
4814 static int
4815 verify_constructor_circularity (tree meth, tree current)
4816 {
4817   tree c;
4818
4819   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4820     {
4821       if (TREE_VALUE (c) == meth)
4822         {
4823           char *t;
4824           if (vcc_list)
4825             {
4826               tree liste;
4827               vcc_list = nreverse (vcc_list);
4828               for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4829                 {
4830                   parse_error_context
4831                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4832                      constructor_circularity_msg
4833                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4834                   java_error_count--;
4835                 }
4836             }
4837           t = xstrdup (lang_printable_name (meth, 0));
4838           parse_error_context (TREE_PURPOSE (c),
4839                                "%s: recursive invocation of constructor `%s'",
4840                                constructor_circularity_msg (current, meth), t);
4841           free (t);
4842           vcc_list = NULL_TREE;
4843           return 1;
4844         }
4845     }
4846   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4847     {
4848       vcc_list = tree_cons (c, current, vcc_list);
4849       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4850         return 1;
4851       vcc_list = TREE_CHAIN (vcc_list);
4852     }
4853   return 0;
4854 }
4855
4856 /* Check modifiers that can be declared but exclusively */
4857
4858 static void
4859 check_modifiers_consistency (int flags)
4860 {
4861   int acc_count = 0;
4862   tree cl = NULL_TREE;
4863
4864   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4865   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4866   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4867   if (acc_count > 1)
4868     parse_error_context
4869       (cl, "Inconsistent member declaration.  At most one of `public', `private', or `protected' may be specified");
4870
4871   acc_count = 0;
4872   cl = NULL_TREE;
4873   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4874   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4875   if (acc_count > 1)
4876     parse_error_context (cl,
4877                          "Inconsistent member declaration.  At most one of `final' or `volatile' may be specified");
4878 }
4879
4880 /* Check the methode header METH for abstract specifics features */
4881
4882 static void
4883 check_abstract_method_header (tree meth)
4884 {
4885   int flags = get_access_flags_from_decl (meth);
4886
4887   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4888                               ACC_ABSTRACT, "abstract method",
4889                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4890   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4891                               ACC_PUBLIC, "abstract method",
4892                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4893
4894   check_modifiers ("Illegal modifier `%s' for interface method",
4895                   flags, INTERFACE_METHOD_MODIFIERS);
4896 }
4897
4898 /* Create a FUNCTION_TYPE node and start augmenting it with the
4899    declared function arguments. Arguments type that can't be resolved
4900    are left as they are, but the returned node is marked as containing
4901    incomplete types.  */
4902
4903 static tree
4904 method_declarator (tree id, tree list)
4905 {
4906   tree arg_types = NULL_TREE, current, node;
4907   tree meth = make_node (FUNCTION_TYPE);
4908   jdep *jdep;
4909
4910   patch_stage = JDEP_NO_PATCH;
4911
4912   if (GET_CPC () == error_mark_node)
4913     return error_mark_node;
4914
4915   /* If we're dealing with an inner class constructor, we hide the
4916      this$<n> decl in the name field of its parameter declaration.  We
4917      also might have to hide the outer context local alias
4918      initializers. Not done when the class is a toplevel class. */
4919   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4920       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4921     {
4922       tree aliases_list, type, thisn;
4923       /* First the aliases, linked to the regular parameters */
4924       aliases_list =
4925         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4926                                                 TREE_TYPE (GET_CPC ()),
4927                                                 NULL_TREE, NULL);
4928       list = chainon (nreverse (aliases_list), list);
4929
4930       /* Then this$<n> */
4931       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4932       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4933       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4934                         list);
4935     }
4936
4937   for (current = list; current; current = TREE_CHAIN (current))
4938     {
4939       int must_chain = 0;
4940       tree wfl_name = TREE_PURPOSE (current);
4941       tree type = TREE_VALUE (current);
4942       tree name = EXPR_WFL_NODE (wfl_name);
4943       tree already, arg_node;
4944       tree type_wfl = NULL_TREE;
4945       tree real_type;
4946
4947       /* Obtain a suitable type for resolution, if necessary */
4948       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4949
4950       /* Process NAME, as it may specify extra dimension(s) for it */
4951       type = build_array_from_name (type, type_wfl, name, &name);
4952       EXPR_WFL_NODE (wfl_name) = name;
4953
4954       real_type = GET_REAL_TYPE (type);
4955       if (TREE_CODE (real_type) == RECORD_TYPE)
4956         {
4957           real_type = promote_type (real_type);
4958           if (TREE_CODE (type) == TREE_LIST)
4959             TREE_PURPOSE (type) = real_type;
4960         }
4961
4962       /* Check redefinition */
4963       for (already = arg_types; already; already = TREE_CHAIN (already))
4964         if (TREE_PURPOSE (already) == name)
4965           {
4966             parse_error_context
4967               (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4968                IDENTIFIER_POINTER (name),
4969                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4970             break;
4971           }
4972
4973       /* If we've an incomplete argument type, we know there is a location
4974          to patch when the type get resolved, later.  */
4975       jdep = NULL;
4976       if (must_chain)
4977         {
4978           patch_stage = JDEP_METHOD;
4979           type = register_incomplete_type (patch_stage,
4980                                            type_wfl, wfl_name, type);
4981           jdep = CLASSD_LAST (ctxp->classd_list);
4982           JDEP_MISC (jdep) = id;
4983         }
4984
4985       /* The argument node: a name and a (possibly) incomplete type.  */
4986       arg_node = build_tree_list (name, real_type);
4987       /* Remember arguments declared final. */
4988       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
4989
4990       if (jdep)
4991         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
4992       TREE_CHAIN (arg_node) = arg_types;
4993       arg_types = arg_node;
4994     }
4995   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
4996   node = build_tree_list (id, meth);
4997   return node;
4998 }
4999
5000 static int
5001 unresolved_type_p (tree wfl, tree *returned)
5002
5003 {
5004   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5005     {
5006       if (returned)
5007         {
5008           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5009           if (decl && current_class && (decl == TYPE_NAME (current_class)))
5010             *returned = TREE_TYPE (decl);
5011           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5012             *returned = TREE_TYPE (GET_CPC ());
5013           else
5014             *returned = NULL_TREE;
5015         }
5016       return 1;
5017     }
5018   if (returned)
5019     *returned = wfl;
5020   return 0;
5021 }
5022
5023 /* From NAME, build a qualified identifier node using the
5024    qualification from the current package definition. */
5025
5026 static tree
5027 parser_qualified_classname (tree name)
5028 {
5029   tree nested_class_name;
5030
5031   if ((nested_class_name = maybe_make_nested_class_name (name)))
5032     return nested_class_name;
5033
5034   if (ctxp->package)
5035     return merge_qualified_name (ctxp->package, name);
5036   else
5037     return name;
5038 }
5039
5040 /* Called once the type a interface extends is resolved. Returns 0 if
5041    everything is OK.  */
5042
5043 static int
5044 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5045 {
5046   tree super_type = TREE_TYPE (super_decl);
5047
5048   /* Has to be an interface */
5049   if (!CLASS_INTERFACE (super_decl))
5050     {
5051       parse_error_context
5052         (this_wfl, "%s `%s' can't implement/extend %s `%s'",
5053          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5054           "Interface" : "Class"),
5055          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5056          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5057          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5058       return 1;
5059     }
5060
5061   /* Check top-level interface access. Inner classes are subject to member
5062      access rules (6.6.1). */
5063   if (! INNER_CLASS_P (super_type)
5064       && check_pkg_class_access (DECL_NAME (super_decl),
5065                                  lookup_cl (this_decl), true))
5066     return 1;
5067
5068   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5069                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5070                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5071   return 0;
5072 }
5073
5074 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5075    0 if everything is OK.  */
5076
5077 static int
5078 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5079 {
5080   tree super_type = TREE_TYPE (super_decl);
5081
5082   /* SUPER should be a CLASS (neither an array nor an interface) */
5083   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5084     {
5085       parse_error_context
5086         (wfl, "Class `%s' can't subclass %s `%s'",
5087          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5088          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5089          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5090       return 1;
5091     }
5092
5093   if (CLASS_FINAL (TYPE_NAME (super_type)))
5094     {
5095       parse_error_context (wfl, "Can't subclass final classes: %s",
5096                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5097       return 1;
5098     }
5099
5100   /* Check top-level class scope. Inner classes are subject to member access
5101      rules (6.6.1). */
5102   if (! INNER_CLASS_P (super_type)
5103       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true)))
5104     return 1;
5105
5106   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5107                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5108                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5109   return 0;
5110 }
5111
5112 /* Create a new dependency list and link it (in a LIFO manner) to the
5113    CTXP list of type dependency list.  */
5114
5115 static void
5116 create_jdep_list (struct parser_ctxt *ctxp)
5117 {
5118   jdeplist *new = xmalloc (sizeof (jdeplist));
5119   new->first = new->last = NULL;
5120   new->next = ctxp->classd_list;
5121   ctxp->classd_list = new;
5122 }
5123
5124 static jdeplist *
5125 reverse_jdep_list (struct parser_ctxt *ctxp)
5126 {
5127   jdeplist *prev = NULL, *current, *next;
5128   for (current = ctxp->classd_list; current; current = next)
5129     {
5130       next = current->next;
5131       current->next = prev;
5132       prev = current;
5133     }
5134   return prev;
5135 }
5136
5137 /* Create a fake pointer based on the ID stored in
5138    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5139    registered again. */
5140
5141 static tree
5142 obtain_incomplete_type (tree type_name)
5143 {
5144   tree ptr = NULL_TREE, name;
5145
5146   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5147     name = EXPR_WFL_NODE (type_name);
5148   else if (INCOMPLETE_TYPE_P (type_name))
5149     name = TYPE_NAME (type_name);
5150   else
5151     abort ();
5152
5153   /* Workaround from build_pointer_type for incomplete types.  */
5154   BUILD_PTR_FROM_NAME (ptr, name);
5155   TYPE_MODE (ptr) = ptr_mode;
5156   layout_type (ptr);
5157
5158   return ptr;
5159 }
5160
5161 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5162    non NULL instead of computing a new fake type based on WFL. The new
5163    dependency is inserted in the current type dependency list, in FIFO
5164    manner.  */
5165
5166 static tree
5167 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5168 {
5169   jdep *new = xmalloc (sizeof (jdep));
5170
5171   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5172     ptr = obtain_incomplete_type (wfl);
5173
5174   JDEP_KIND (new) = kind;
5175   JDEP_DECL (new) = decl;
5176   JDEP_TO_RESOLVE (new) = ptr;
5177   JDEP_WFL (new) = wfl;
5178   JDEP_CHAIN (new) = NULL;
5179   JDEP_MISC (new) = NULL_TREE;
5180   /* For some dependencies, set the enclosing class of the current
5181      class to be the enclosing context */
5182   if ((kind == JDEP_INTERFACE  || kind == JDEP_ANONYMOUS)
5183       && GET_ENCLOSING_CPC ())
5184     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5185   else if (kind == JDEP_SUPER)
5186     JDEP_ENCLOSING (new) = (GET_ENCLOSING_CPC () ?
5187                             TREE_VALUE (GET_ENCLOSING_CPC ()) : NULL_TREE);
5188   else
5189     JDEP_ENCLOSING (new) = GET_CPC ();
5190   JDEP_GET_PATCH (new) = (tree *)NULL;
5191
5192   JDEP_INSERT (ctxp->classd_list, new);
5193
5194   return ptr;
5195 }
5196
5197 /* This checks for circular references with innerclasses. We start
5198    from SOURCE and should never reach TARGET. Extended/implemented
5199    types in SOURCE have their enclosing context checked not to reach
5200    TARGET. When the last enclosing context of SOURCE is reached, its
5201    extended/implemented types are also checked not to reach TARGET.
5202    In case of error, WFL of the offending type is returned; NULL_TREE
5203    otherwise.  */
5204
5205 static tree
5206 check_inner_circular_reference (tree source, tree target)
5207 {
5208   tree basetype_vec = TYPE_BINFO_BASETYPES (source);
5209   tree ctx, cl;
5210   int i;
5211
5212   if (!basetype_vec)
5213     return NULL_TREE;
5214
5215   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5216     {
5217       tree su;
5218
5219       /* We can end up with a NULL_TREE or an incomplete type here if
5220          we encountered previous type resolution errors. It's safe to
5221          simply ignore these cases.  */
5222       if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
5223         continue;
5224       su = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
5225       if (INCOMPLETE_TYPE_P (su))
5226         continue;
5227
5228       if (inherits_from_p (su, target))
5229         return lookup_cl (TYPE_NAME (su));
5230
5231       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5232         {
5233           /* An enclosing context shouldn't be TARGET */
5234           if (ctx == TYPE_NAME (target))
5235             return lookup_cl (TYPE_NAME (su));
5236
5237           /* When we reach the enclosing last context, start a check
5238              on it, with the same target */
5239           if (! DECL_CONTEXT (ctx) &&
5240               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5241             return cl;
5242         }
5243     }
5244   return NULL_TREE;
5245 }
5246
5247 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5248    offending type if a circularity is detected. NULL_TREE is returned
5249    otherwise. TYPE can be an interface or a class.   */
5250
5251 static tree
5252 check_circular_reference (tree type)
5253 {
5254   tree basetype_vec = TYPE_BINFO_BASETYPES (type);
5255   int i;
5256
5257   if (!basetype_vec)
5258     return NULL_TREE;
5259
5260   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5261     {
5262       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5263         return lookup_cl (TYPE_NAME (type));
5264       return NULL_TREE;
5265     }
5266
5267   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5268     {
5269       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
5270       if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
5271           && interface_of_p (type, BINFO_TYPE (vec_elt)))
5272         return lookup_cl (TYPE_NAME (BINFO_TYPE (vec_elt)));
5273     }
5274   return NULL_TREE;
5275 }
5276
5277 void
5278 java_check_circular_reference (void)
5279 {
5280   tree current;
5281   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5282     {
5283       tree type = TREE_TYPE (current);
5284       tree cl;
5285
5286       cl = check_circular_reference (type);
5287       if (! cl)
5288         cl = check_inner_circular_reference (type, type);
5289       if (cl)
5290         parse_error_context (cl, "Cyclic class inheritance%s",
5291                              (cyclic_inheritance_report ?
5292                               cyclic_inheritance_report : ""));
5293     }
5294 }
5295
5296 /* Augment the parameter list PARM with parameters crafted to
5297    initialize outer context locals aliases. Through ARTIFICIAL, a
5298    count is kept of the number of crafted parameters. MODE governs
5299    what eventually gets created: something suitable for a function
5300    creation or a function invocation, either the constructor or
5301    finit$.  */
5302
5303 static tree
5304 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5305                                         int *artificial)
5306 {
5307   tree field;
5308   tree additional_parms = NULL_TREE;
5309
5310   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5311     if (FIELD_LOCAL_ALIAS (field))
5312       {
5313         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5314         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5315         tree mangled_id;
5316
5317         switch (mode)
5318           {
5319           case AIPL_FUNCTION_DECLARATION:
5320             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5321                                                          &buffer [4]);
5322             purpose = build_wfl_node (mangled_id);
5323             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5324               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5325             else
5326               value = TREE_TYPE (field);
5327             break;
5328
5329           case AIPL_FUNCTION_CREATION:
5330             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5331                                                          &buffer [4]);
5332             value = TREE_TYPE (field);
5333             break;
5334
5335           case AIPL_FUNCTION_FINIT_INVOCATION:
5336             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5337                                                          &buffer [4]);
5338             /* Now, this is wrong. purpose should always be the NAME
5339                of something and value its matching value (decl, type,
5340                etc...) FIXME -- but there is a lot to fix. */
5341
5342             /* When invoked for this kind of operation, we already
5343                know whether a field is used or not. */
5344             purpose = TREE_TYPE (field);
5345             value = build_wfl_node (mangled_id);
5346             break;
5347
5348           case AIPL_FUNCTION_CTOR_INVOCATION:
5349             /* There are two case: the constructor invocation happens
5350                outside the local inner, in which case, locales from the outer
5351                context are directly used.
5352
5353                Otherwise, we fold to using the alias directly. */
5354             if (class_type == current_class)
5355               value = field;
5356             else
5357               {
5358                 name = get_identifier (&buffer[4]);
5359                 value = IDENTIFIER_LOCAL_VALUE (name);
5360               }
5361             break;
5362           }
5363         additional_parms = tree_cons (purpose, value, additional_parms);
5364         if (artificial)
5365           *artificial +=1;
5366       }
5367   if (additional_parms)
5368     {
5369       if (ANONYMOUS_CLASS_P (class_type)
5370           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5371         additional_parms = nreverse (additional_parms);
5372       parm = chainon (additional_parms, parm);
5373     }
5374
5375    return parm;
5376 }
5377
5378 /* Craft a constructor for CLASS_DECL -- what we should do when none
5379    where found. ARGS is non NULL when a special signature must be
5380    enforced. This is the case for anonymous classes.  */
5381
5382 static tree
5383 craft_constructor (tree class_decl, tree args)
5384 {
5385   tree class_type = TREE_TYPE (class_decl);
5386   tree parm = NULL_TREE;
5387   int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5388                ACC_PUBLIC : 0);
5389   int i = 0, artificial = 0;
5390   tree decl, ctor_name;
5391   char buffer [80];
5392
5393   /* The constructor name is <init> unless we're dealing with an
5394      anonymous class, in which case the name will be fixed after having
5395      be expanded. */
5396   if (ANONYMOUS_CLASS_P (class_type))
5397     ctor_name = DECL_NAME (class_decl);
5398   else
5399     ctor_name = init_identifier_node;
5400
5401   /* If we're dealing with an inner class constructor, we hide the
5402      this$<n> decl in the name field of its parameter declaration. */
5403   if (PURE_INNER_CLASS_TYPE_P (class_type))
5404     {
5405       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5406       parm = tree_cons (build_current_thisn (class_type),
5407                         build_pointer_type (type), parm);
5408
5409       /* Some more arguments to be hidden here. The values of the local
5410          variables of the outer context that the inner class needs to see. */
5411       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5412                                                      class_type, parm,
5413                                                      &artificial);
5414     }
5415
5416   /* Then if there are any args to be enforced, enforce them now */
5417   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5418     {
5419       sprintf (buffer, "parm%d", i++);
5420       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5421     }
5422
5423   CRAFTED_PARAM_LIST_FIXUP (parm);
5424   decl = create_artificial_method (class_type, flags, void_type_node,
5425                                    ctor_name, parm);
5426   fix_method_argument_names (parm, decl);
5427   /* Now, mark the artificial parameters. */
5428   DECL_FUNCTION_NAP (decl) = artificial;
5429   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5430   DECL_INLINE (decl) = 1;
5431   return decl;
5432 }
5433
5434
5435 /* Fix the constructors. This will be called right after circular
5436    references have been checked. It is necessary to fix constructors
5437    early even if no code generation will take place for that class:
5438    some generated constructor might be required by the class whose
5439    compilation triggered this one to be simply loaded.  */
5440
5441 void
5442 java_fix_constructors (void)
5443 {
5444   tree current;
5445
5446   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5447     {
5448       tree class_type = TREE_TYPE (current);
5449       int saw_ctor = 0;
5450       tree decl;
5451
5452       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5453         continue;
5454
5455       output_class = current_class = class_type;
5456       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5457         {
5458           if (DECL_CONSTRUCTOR_P (decl))
5459             {
5460               fix_constructors (decl);
5461               saw_ctor = 1;
5462             }
5463         }
5464
5465       /* Anonymous class constructor can't be generated that early. */
5466       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5467         craft_constructor (current, NULL_TREE);
5468     }
5469 }
5470
5471 /* safe_layout_class just makes sure that we can load a class without
5472    disrupting the current_class, input_file, lineno, etc, information
5473    about the class processed currently.  */
5474
5475 void
5476 safe_layout_class (tree class)
5477 {
5478   tree save_current_class = current_class;
5479   location_t save_location = input_location;
5480
5481   layout_class (class);
5482
5483   current_class = save_current_class;
5484   input_location = save_location;
5485 }
5486
5487 static tree
5488 jdep_resolve_class (jdep *dep)
5489 {
5490   tree decl;
5491
5492   if (JDEP_RESOLVED_P (dep))
5493     decl = JDEP_RESOLVED_DECL (dep);
5494   else
5495     {
5496       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5497                             JDEP_DECL (dep), JDEP_WFL (dep));
5498       JDEP_RESOLVED (dep, decl);
5499       /* If there is no WFL, that's ok.  We generate this warning
5500          elsewhere.  */
5501       if (decl && JDEP_WFL (dep) != NULL_TREE)
5502         check_deprecation (JDEP_WFL (dep), decl);
5503     }
5504
5505   if (!decl)
5506     complete_class_report_errors (dep);
5507   else if (PURE_INNER_CLASS_DECL_P (decl))
5508     {
5509       tree inner = TREE_TYPE (decl);
5510       if (! CLASS_LOADED_P (inner))
5511         {
5512           safe_layout_class (inner);
5513           if (TYPE_SIZE (inner) == error_mark_node)
5514             TYPE_SIZE (inner) = NULL_TREE;
5515         }
5516       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5517     }
5518   return decl;
5519 }
5520
5521 /* Complete unsatisfied class declaration and their dependencies */
5522
5523 void
5524 java_complete_class (void)
5525 {
5526   tree cclass;
5527   jdeplist *cclassd;
5528   int error_found;
5529   tree type;
5530
5531   /* Process imports */
5532   process_imports ();
5533
5534   /* Reverse things so we have the right order */
5535   ctxp->class_list = nreverse (ctxp->class_list);
5536   ctxp->classd_list = reverse_jdep_list (ctxp);
5537
5538   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5539        cclass && cclassd;
5540        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5541     {
5542       jdep *dep;
5543
5544       /* We keep the compilation unit imports in the class so that
5545          they can be used later to resolve type dependencies that
5546          aren't necessary to solve now. */
5547       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5548       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5549
5550       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5551         {
5552           tree decl;
5553           if (!(decl = jdep_resolve_class (dep)))
5554             continue;
5555
5556           /* Now it's time to patch */
5557           switch (JDEP_KIND (dep))
5558             {
5559             case JDEP_SUPER:
5560               /* Simply patch super */
5561               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5562                 continue;
5563               BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5564                 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5565               break;
5566
5567             case JDEP_FIELD:
5568               {
5569                 /* We do part of the job done in add_field */
5570                 tree field_decl = JDEP_DECL (dep);
5571                 tree field_type = TREE_TYPE (decl);
5572                 if (TREE_CODE (field_type) == RECORD_TYPE)
5573                   field_type = promote_type (field_type);
5574                 TREE_TYPE (field_decl) = field_type;
5575                 DECL_ALIGN (field_decl) = 0;
5576                 DECL_USER_ALIGN (field_decl) = 0;
5577                 layout_decl (field_decl, 0);
5578                 SOURCE_FRONTEND_DEBUG
5579                   (("Completed field/var decl `%s' with `%s'",
5580                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5581                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5582                 break;
5583               }
5584             case JDEP_METHOD:   /* We start patching a method */
5585             case JDEP_METHOD_RETURN:
5586               error_found = 0;
5587               while (1)
5588                 {
5589                   if (decl)
5590                     {
5591                       type = TREE_TYPE(decl);
5592                       if (TREE_CODE (type) == RECORD_TYPE)
5593                         type = promote_type (type);
5594                       JDEP_APPLY_PATCH (dep, type);
5595                       SOURCE_FRONTEND_DEBUG
5596                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5597                            "Completing fct `%s' with ret type `%s'":
5598                            "Completing arg `%s' with type `%s'"),
5599                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5600                                               (JDEP_DECL_WFL (dep))),
5601                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5602                     }
5603                   else
5604                     error_found = 1;
5605                   dep = JDEP_CHAIN (dep);
5606                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5607                     break;
5608                   else
5609                     decl = jdep_resolve_class (dep);
5610                 }
5611               if (!error_found)
5612                 {
5613                   tree mdecl = JDEP_DECL (dep), signature;
5614                   /* Recompute and reset the signature, check first that
5615                      all types are now defined. If they're not,
5616                      don't build the signature. */
5617                   if (check_method_types_complete (mdecl))
5618                     {
5619                       signature = build_java_signature (TREE_TYPE (mdecl));
5620                       set_java_signature (TREE_TYPE (mdecl), signature);
5621                     }
5622                 }
5623               else
5624                 continue;
5625               break;
5626
5627             case JDEP_INTERFACE:
5628               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5629                                                 JDEP_WFL (dep)))
5630                 continue;
5631               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5632               break;
5633
5634             case JDEP_PARM:
5635             case JDEP_VARIABLE:
5636               type = TREE_TYPE(decl);
5637               if (TREE_CODE (type) == RECORD_TYPE)
5638                 type = promote_type (type);
5639               JDEP_APPLY_PATCH (dep, type);
5640               break;
5641
5642             case JDEP_TYPE:
5643               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5644               SOURCE_FRONTEND_DEBUG
5645                 (("Completing a random type dependency on a '%s' node",
5646                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5647               break;
5648
5649             case JDEP_EXCEPTION:
5650               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5651               SOURCE_FRONTEND_DEBUG
5652                 (("Completing `%s' `throws' argument node",
5653                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5654               break;
5655
5656             case JDEP_ANONYMOUS:
5657               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5658               break;
5659
5660             default:
5661               abort ();
5662             }
5663         }
5664     }
5665   return;
5666 }
5667
5668 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5669    array.  */
5670
5671 static tree
5672 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5673 {
5674   tree tname = TYPE_NAME (class_type);
5675   tree resolved_type = TREE_TYPE (class_type);
5676   int array_dims = 0;
5677   tree resolved_type_decl;
5678
5679   if (resolved_type != NULL_TREE)
5680     {
5681       tree resolved_type_decl = TYPE_NAME (resolved_type);
5682       if (resolved_type_decl == NULL_TREE
5683           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5684         {
5685           resolved_type_decl = build_decl (TYPE_DECL,
5686                                            TYPE_NAME (class_type),
5687                                            resolved_type);
5688         }
5689       return resolved_type_decl;
5690     }
5691
5692   /* 1- Check to see if we have an array. If true, find what we really
5693      want to resolve  */
5694   if ((array_dims = build_type_name_from_array_name (tname,
5695                                                      &TYPE_NAME (class_type))))
5696     WFL_STRIP_BRACKET (cl, cl);
5697
5698   /* 2- Resolve the bare type */
5699   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5700                                                decl, cl)))
5701     return NULL_TREE;
5702   resolved_type = TREE_TYPE (resolved_type_decl);
5703
5704   /* 3- If we have an array, reconstruct the array down to its nesting */
5705   if (array_dims)
5706     {
5707       for (; array_dims; array_dims--)
5708         resolved_type = build_java_array_type (resolved_type, -1);
5709       resolved_type_decl = TYPE_NAME (resolved_type);
5710     }
5711   TREE_TYPE (class_type) = resolved_type;
5712   return resolved_type_decl;
5713 }
5714
5715 /* Effectively perform the resolution of class CLASS_TYPE.  DECL or CL
5716    are used to report error messages; CL must either be NULL_TREE or a
5717    WFL wrapping a class.  Do not try to replace TYPE_NAME (class_type)
5718    by a variable, since it is changed by find_in_imports{_on_demand}
5719    and (but it doesn't really matter) qualify_and_find.  */
5720
5721 tree
5722 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5723 {
5724   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5725   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5726   tree decl_result;
5727   htab_t circularity_hash;
5728
5729   if (QUALIFIED_P (TYPE_NAME (class_type)))
5730     {
5731       /* If the type name is of the form `Q . Id', then Q is either a
5732          package name or a class name.  First we try to find Q as a
5733          class and then treat Id as a member type.  If we can't find Q
5734          as a class then we fall through.  */
5735       tree q, left, left_type, right;
5736       if (breakdown_qualified (&left, &right, TYPE_NAME (class_type)) == 0)
5737         {
5738           BUILD_PTR_FROM_NAME (left_type, left);
5739           q = do_resolve_class (enclosing, left_type, decl, cl);
5740           if (q)
5741             {
5742               enclosing = q;
5743               saved_enclosing_type = TREE_TYPE (q);
5744               BUILD_PTR_FROM_NAME (class_type, right);
5745             }
5746         }
5747     }
5748
5749   if (enclosing)
5750     {
5751       /* This hash table is used to register the classes we're going
5752          through when searching the current class as an inner class, in
5753          order to detect circular references. Remember to free it before
5754          returning the section 0- of this function. */
5755       circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5756                                       NULL);
5757
5758       /* 0- Search in the current class as an inner class.
5759          Maybe some code here should be added to load the class or
5760          something, at least if the class isn't an inner class and ended
5761          being loaded from class file. FIXME. */
5762       while (enclosing)
5763         {
5764           new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5765                                                 &super, class_type);
5766           if (new_class_decl)
5767             break;
5768
5769           /* If we haven't found anything because SUPER reached Object and
5770              ENCLOSING happens to be an innerclass, try the enclosing context. */
5771           if ((!super || super == object_type_node) &&
5772               enclosing && INNER_CLASS_DECL_P (enclosing))
5773             enclosing = DECL_CONTEXT (enclosing);
5774           else
5775             enclosing = NULL_TREE;
5776         }
5777
5778       htab_delete (circularity_hash);
5779
5780       if (new_class_decl)
5781         return new_class_decl;
5782     }
5783
5784   /* 1- Check for the type in single imports. This will change
5785      TYPE_NAME() if something relevant is found */
5786   find_in_imports (saved_enclosing_type, class_type);
5787
5788   /* 2- And check for the type in the current compilation unit */
5789   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5790     {
5791       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5792           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5793         load_class (TYPE_NAME (class_type), 0);
5794       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5795     }
5796
5797   /* 3- Search according to the current package definition */
5798   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5799     {
5800       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5801                                              TYPE_NAME (class_type))))
5802         return new_class_decl;
5803     }
5804
5805   /* 4- Check the import on demands. Don't allow bar.baz to be
5806      imported from foo.* */
5807   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5808     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5809       return NULL_TREE;
5810
5811   /* If found in find_in_imports_on_demand, the type has already been
5812      loaded. */
5813   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5814     return new_class_decl;
5815
5816   /* 5- Try with a name qualified with the package name we've seen so far */
5817   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5818     {
5819       tree package;
5820
5821       /* If there is a current package (ctxp->package), it's the first
5822          element of package_list and we can skip it. */
5823       for (package = (ctxp->package ?
5824                       TREE_CHAIN (package_list) : package_list);
5825            package; package = TREE_CHAIN (package))
5826         if ((new_class_decl = qualify_and_find (class_type,
5827                                                TREE_PURPOSE (package),
5828                                                TYPE_NAME (class_type))))
5829           return new_class_decl;
5830     }
5831
5832   /* 5- Check another compilation unit that bears the name of type */
5833   load_class (TYPE_NAME (class_type), 0);
5834
5835   if (!cl)
5836     cl = lookup_cl (decl);
5837
5838   /* If we don't have a value for CL, then we're being called recursively.
5839      We can't check package access just yet, but it will be taken care of
5840      by the caller. */
5841   if (cl)
5842     {
5843       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true))
5844         return NULL_TREE;
5845     }
5846
5847   /* 6- Last call for a resolution */
5848   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5849
5850   /* The final lookup might have registered a.b.c into a.b$c If we
5851      failed at the first lookup, progressively change the name if
5852      applicable and use the matching DECL instead. */
5853   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5854     {
5855       char *separator;
5856       tree name = TYPE_NAME (class_type);
5857       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
5858
5859       strcpy (namebuffer, IDENTIFIER_POINTER (name));
5860
5861       do {
5862
5863        /* Reach the last '.', and if applicable, replace it by a `$' and
5864           see if this exists as a type. */
5865        if ((separator = strrchr (namebuffer, '.')))
5866          {
5867            *separator = '$';
5868            name = get_identifier (namebuffer);
5869            decl_result = IDENTIFIER_CLASS_VALUE (name);
5870          }
5871       } while (!decl_result && separator);
5872     }
5873   return decl_result;
5874 }
5875
5876 static tree
5877 qualify_and_find (tree class_type, tree package, tree name)
5878 {
5879   tree new_qualified = merge_qualified_name (package, name);
5880   tree new_class_decl;
5881
5882   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5883     load_class (new_qualified, 0);
5884   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5885     {
5886       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5887           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5888         load_class (new_qualified, 0);
5889       TYPE_NAME (class_type) = new_qualified;
5890       return IDENTIFIER_CLASS_VALUE (new_qualified);
5891     }
5892   return NULL_TREE;
5893 }
5894
5895 /* Resolve NAME and lay it out (if not done and if not the current
5896    parsed class). Return a decl node. This function is meant to be
5897    called when type resolution is necessary during the walk pass.  */
5898
5899 static tree
5900 resolve_and_layout (tree something, tree cl)
5901 {
5902   tree decl, decl_type;
5903
5904   /* Don't do that on the current class */
5905   if (something == current_class)
5906     return TYPE_NAME (current_class);
5907
5908   /* Don't do anything for void and other primitive types */
5909   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5910     return NULL_TREE;
5911
5912   /* Pointer types can be reall pointer types or fake pointers. When
5913      finding a real pointer, recheck for primitive types */
5914   if (TREE_CODE (something) == POINTER_TYPE)
5915     {
5916       if (TREE_TYPE (something))
5917         {
5918           something = TREE_TYPE (something);
5919           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5920             return NULL_TREE;
5921         }
5922       else
5923         something = TYPE_NAME (something);
5924     }
5925
5926   /* Don't do anything for arrays of primitive types */
5927   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5928       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5929     return NULL_TREE;
5930
5931   /* Something might be a WFL */
5932   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5933     something = EXPR_WFL_NODE (something);
5934
5935   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5936      TYPE_DECL or a real TYPE */
5937   else if (TREE_CODE (something) != IDENTIFIER_NODE)
5938     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5939             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5940
5941   if (!(decl = resolve_no_layout (something, cl)))
5942     return NULL_TREE;
5943
5944   /* Resolve and layout if necessary */
5945   decl_type = TREE_TYPE (decl);
5946   layout_class_methods (decl_type);
5947   /* Check methods */
5948   if (CLASS_FROM_SOURCE_P (decl_type))
5949     java_check_methods (decl);
5950   /* Layout the type if necessary */
5951   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5952     safe_layout_class (decl_type);
5953
5954   return decl;
5955 }
5956
5957 /* Resolve a class, returns its decl but doesn't perform any
5958    layout. The current parsing context is saved and restored */
5959
5960 static tree
5961 resolve_no_layout (tree name, tree cl)
5962 {
5963   tree ptr, decl;
5964   BUILD_PTR_FROM_NAME (ptr, name);
5965   java_parser_context_save_global ();
5966   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5967   java_parser_context_restore_global ();
5968
5969   return decl;
5970 }
5971
5972 /* Called when reporting errors. Skip the '[]'s in a complex array
5973    type description that failed to be resolved. purify_type_name can't
5974    use an identifier tree.  */
5975
5976 static const char *
5977 purify_type_name (const char *name)
5978 {
5979   int len = strlen (name);
5980   int bracket_found;
5981
5982   STRING_STRIP_BRACKETS (name, len, bracket_found);
5983   if (bracket_found)
5984     {
5985       char *stripped_name = xmemdup (name, len, len+1);
5986       stripped_name [len] = '\0';
5987       return stripped_name;
5988     }
5989   return name;
5990 }
5991
5992 /* The type CURRENT refers to can't be found. We print error messages.  */
5993
5994 static void
5995 complete_class_report_errors (jdep *dep)
5996 {
5997   const char *name;
5998
5999   if (!JDEP_WFL (dep))
6000     return;
6001
6002   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6003   switch (JDEP_KIND (dep))
6004     {
6005     case JDEP_SUPER:
6006       parse_error_context
6007         (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
6008          purify_type_name (name),
6009          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6010       break;
6011     case JDEP_FIELD:
6012       parse_error_context
6013         (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
6014          purify_type_name (name),
6015          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6016       break;
6017     case JDEP_METHOD:           /* Covers arguments */
6018       parse_error_context
6019         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
6020          purify_type_name (name),
6021          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6022          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6023       break;
6024     case JDEP_METHOD_RETURN:    /* Covers return type */
6025       parse_error_context
6026         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
6027          purify_type_name (name),
6028          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6029       break;
6030     case JDEP_INTERFACE:
6031       parse_error_context
6032         (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
6033          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6034          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6035          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6036       break;
6037     case JDEP_VARIABLE:
6038       parse_error_context
6039         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
6040          purify_type_name (IDENTIFIER_POINTER
6041                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6042          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6043       break;
6044     case JDEP_EXCEPTION:        /* As specified by `throws' */
6045       parse_error_context
6046           (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6047          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6048       break;
6049     default:
6050       /* Fix for -Wall. Just break doing nothing. The error will be
6051          caught later */
6052       break;
6053     }
6054 }
6055
6056 /* Return a static string containing the DECL prototype string. If
6057    DECL is a constructor, use the class name instead of the form
6058    <init> */
6059
6060 static const char *
6061 get_printable_method_name (tree decl)
6062 {
6063   const char *to_return;
6064   tree name = NULL_TREE;
6065
6066   if (DECL_CONSTRUCTOR_P (decl))
6067     {
6068       name = DECL_NAME (decl);
6069       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6070     }
6071
6072   to_return = lang_printable_name (decl, 0);
6073   if (DECL_CONSTRUCTOR_P (decl))
6074     DECL_NAME (decl) = name;
6075
6076   return to_return;
6077 }
6078
6079 /* Track method being redefined inside the same class. As a side
6080    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6081    function it's a FWL, so we can track errors more accurately.)  */
6082
6083 static int
6084 check_method_redefinition (tree class, tree method)
6085 {
6086   tree redef, sig;
6087
6088   /* There's no need to verify <clinit> and finit$ and instinit$ */
6089   if (DECL_CLINIT_P (method)
6090       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6091     return 0;
6092
6093   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6094   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6095     {
6096       if (redef == method)
6097         break;
6098       if (DECL_NAME (redef) == DECL_NAME (method)
6099           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6100           && !DECL_ARTIFICIAL (method))
6101         {
6102           parse_error_context
6103             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6104              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6105              get_printable_method_name (redef));
6106           return 1;
6107         }
6108     }
6109   return 0;
6110 }
6111
6112 /* Return 1 if check went ok, 0 otherwise.  */
6113 static int
6114 check_abstract_method_definitions (int do_interface, tree class_decl,
6115                                    tree type)
6116 {
6117   tree class = TREE_TYPE (class_decl);
6118   tree method, end_type;
6119   int ok = 1;
6120
6121   end_type = (do_interface ? object_type_node : type);
6122   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6123     {
6124       tree other_super, other_method, method_sig, method_name;
6125       int found = 0;
6126       int end_type_reached = 0;
6127
6128       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6129         continue;
6130
6131       /* Now verify that somewhere in between TYPE and CLASS,
6132          abstract method METHOD gets a non abstract definition
6133          that is inherited by CLASS.  */
6134
6135       method_sig = build_java_signature (TREE_TYPE (method));
6136       method_name = DECL_NAME (method);
6137       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6138         method_name = EXPR_WFL_NODE (method_name);
6139
6140       other_super = class;
6141       do {
6142         if (other_super == end_type)
6143           end_type_reached = 1;
6144
6145         /* Method search */
6146         for (other_method = TYPE_METHODS (other_super); other_method;
6147             other_method = TREE_CHAIN (other_method))
6148           {
6149             tree s = build_java_signature (TREE_TYPE (other_method));
6150             tree other_name = DECL_NAME (other_method);
6151
6152             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6153               other_name = EXPR_WFL_NODE (other_name);
6154             if (!DECL_CLINIT_P (other_method)
6155                 && !DECL_CONSTRUCTOR_P (other_method)
6156                 && method_name == other_name
6157                 && method_sig == s
6158                 && !METHOD_ABSTRACT (other_method))
6159              {
6160                found = 1;
6161                break;
6162              }
6163           }
6164         other_super = CLASSTYPE_SUPER (other_super);
6165       } while (!end_type_reached);
6166
6167       /* Report that abstract METHOD didn't find an implementation
6168          that CLASS can use. */
6169       if (!found)
6170         {
6171           char *t = xstrdup (lang_printable_name
6172                             (TREE_TYPE (TREE_TYPE (method)), 0));
6173           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6174
6175           parse_error_context
6176             (lookup_cl (class_decl),
6177              "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",
6178              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6179              t, lang_printable_name (method, 0),
6180              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6181               "interface" : "class"),
6182              IDENTIFIER_POINTER (ccn),
6183              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6184              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6185           ok = 0;
6186           free (t);
6187         }
6188     }
6189
6190   if (ok && do_interface)
6191     {
6192       /* Check for implemented interfaces. */
6193       int i;
6194       tree vector = TYPE_BINFO_BASETYPES (type);
6195       for (i = 1; ok && vector && i < TREE_VEC_LENGTH (vector); i++)
6196         {
6197           tree super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6198           ok = check_abstract_method_definitions (1, class_decl, super);
6199         }
6200     }
6201
6202   return ok;
6203 }
6204
6205 /* Check that CLASS_DECL somehow implements all inherited abstract
6206    methods.  */
6207
6208 static void
6209 java_check_abstract_method_definitions (tree class_decl)
6210 {
6211   tree class = TREE_TYPE (class_decl);
6212   tree super, vector;
6213   int i;
6214
6215   if (CLASS_ABSTRACT (class_decl))
6216     return;
6217
6218   /* Check for inherited types */
6219   super = class;
6220   do {
6221     super = CLASSTYPE_SUPER (super);
6222     check_abstract_method_definitions (0, class_decl, super);
6223   } while (super != object_type_node);
6224
6225   /* Check for implemented interfaces. */
6226   vector = TYPE_BINFO_BASETYPES (class);
6227   for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
6228     {
6229       super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6230       check_abstract_method_definitions (1, class_decl, super);
6231     }
6232 }
6233
6234 /* Check all the types method DECL uses and return 1 if all of them
6235    are now complete, 0 otherwise. This is used to check whether its
6236    safe to build a method signature or not.  */
6237
6238 static int
6239 check_method_types_complete (tree decl)
6240 {
6241   tree type = TREE_TYPE (decl);
6242   tree args;
6243
6244   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6245     return 0;
6246
6247   args = TYPE_ARG_TYPES (type);
6248   if (TREE_CODE (type) == METHOD_TYPE)
6249     args = TREE_CHAIN (args);
6250   for (; args != end_params_node; args = TREE_CHAIN (args))
6251     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6252       return 0;
6253
6254   return 1;
6255 }
6256
6257 /* Visible interface to check methods contained in CLASS_DECL */
6258
6259 void
6260 java_check_methods (tree class_decl)
6261 {
6262   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6263     return;
6264
6265   if (CLASS_INTERFACE (class_decl))
6266     java_check_abstract_methods (class_decl);
6267   else
6268     java_check_regular_methods (class_decl);
6269
6270   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6271 }
6272
6273 /* Like not_accessible_p, but doesn't refer to the current class at
6274    all.  */
6275 static bool
6276 hack_is_accessible_p (tree member, tree from_where)
6277 {
6278   int flags = get_access_flags_from_decl (member);
6279
6280   if (from_where == DECL_CONTEXT (member)
6281       || (flags & ACC_PUBLIC))
6282     return true;
6283
6284   if ((flags & ACC_PROTECTED))
6285     {
6286       if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6287         return true;
6288     }
6289
6290   if ((flags & ACC_PRIVATE))
6291     return false;
6292
6293   /* Package private, or protected.  */
6294   return in_same_package (TYPE_NAME (from_where),
6295                           TYPE_NAME (DECL_CONTEXT (member)));
6296 }
6297
6298 /* Check all the methods of CLASS_DECL. Methods are first completed
6299    then checked according to regular method existence rules.  If no
6300    constructor for CLASS_DECL were encountered, then build its
6301    declaration.  */
6302 static void
6303 java_check_regular_methods (tree class_decl)
6304 {
6305   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6306   tree method;
6307   tree class = TREE_TYPE (class_decl);
6308   tree found = NULL_TREE;
6309   tree mthrows;
6310
6311   /* It is not necessary to check methods defined in java.lang.Object */
6312   if (class == object_type_node)
6313     return;
6314
6315   if (!TYPE_NVIRTUALS (class))
6316     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6317
6318   /* Should take interfaces into account. FIXME */
6319   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6320     {
6321       tree sig;
6322       tree method_wfl = DECL_FUNCTION_WFL (method);
6323       int aflags;
6324
6325       /* Check for redefinitions */
6326       if (check_method_redefinition (class, method))
6327         continue;
6328
6329       /* We verify things thrown by the method.  They must inherit from
6330          java.lang.Throwable.  */
6331       for (mthrows = DECL_FUNCTION_THROWS (method);
6332            mthrows; mthrows = TREE_CHAIN (mthrows))
6333         {
6334           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6335             parse_error_context
6336               (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6337                IDENTIFIER_POINTER
6338                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6339         }
6340
6341       /* If we see one constructor a mark so we don't generate the
6342          default one.  Also skip other verifications: constructors
6343          can't be inherited hence hidden or overridden.  */
6344       if (DECL_CONSTRUCTOR_P (method))
6345         {
6346           saw_constructor = 1;
6347           continue;
6348         }
6349
6350       sig = build_java_argument_signature (TREE_TYPE (method));
6351       found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6352                                               SEARCH_SUPER | SEARCH_INTERFACE);
6353
6354       /* Inner class can't declare static methods */
6355       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6356         {
6357           char *t = xstrdup (lang_printable_name (class, 0));
6358           parse_error_context
6359             (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6360              lang_printable_name (method, 0), t);
6361           free (t);
6362         }
6363
6364       /* Nothing overrides or it's a private method. */
6365       if (!found)
6366         continue;
6367       if (METHOD_PRIVATE (found))
6368         {
6369           found = NULL_TREE;
6370           continue;
6371         }
6372
6373       /* If `found' is declared in an interface, make sure the
6374          modifier matches. */
6375       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6376           && clinit_identifier_node != DECL_NAME (found)
6377           && !METHOD_PUBLIC (method))
6378         {
6379           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6380           parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6381                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6382                                lang_printable_name (method, 0),
6383                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6384         }
6385
6386       /* Can't override a method with the same name and different return
6387          types. */
6388       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6389         {
6390           char *t = xstrdup
6391             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6392           parse_error_context
6393             (method_wfl,
6394              "Method `%s' was defined with return type `%s' in class `%s'",
6395              lang_printable_name (found, 0), t,
6396              IDENTIFIER_POINTER
6397                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6398           free (t);
6399         }
6400
6401       aflags = get_access_flags_from_decl (found);
6402
6403       /* Can't override final. Can't override static. */
6404       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6405         {
6406           /* Static *can* override static */
6407           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6408             continue;
6409           parse_error_context
6410             (method_wfl,
6411              "%s methods can't be overridden. Method `%s' is %s in class `%s'",
6412              (METHOD_FINAL (found) ? "Final" : "Static"),
6413              lang_printable_name (found, 0),
6414              (METHOD_FINAL (found) ? "final" : "static"),
6415              IDENTIFIER_POINTER
6416                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6417           continue;
6418         }
6419
6420       /* Static method can't override instance method. */
6421       if (METHOD_STATIC (method))
6422         {
6423           parse_error_context
6424             (method_wfl,
6425              "Instance methods can't be overridden by a static method. Method `%s' is an instance method in class `%s'",
6426              lang_printable_name (found, 0),
6427              IDENTIFIER_POINTER
6428                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6429           continue;
6430         }
6431
6432       /* - Overriding/hiding public must be public
6433          - Overriding/hiding protected must be protected or public
6434          - If the overridden or hidden method has default (package)
6435            access, then the overriding or hiding method must not be
6436            private; otherwise, a compile-time error occurs.  If
6437            `found' belongs to an interface, things have been already
6438            taken care of.  */
6439       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6440           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6441               || (METHOD_PROTECTED (found)
6442                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6443               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6444                   && METHOD_PRIVATE (method))))
6445         {
6446           parse_error_context
6447             (method_wfl,
6448              "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6449              (METHOD_PUBLIC (method) ? "public" :
6450               (METHOD_PRIVATE (method) ? "private" : "protected")),
6451              IDENTIFIER_POINTER (DECL_NAME
6452                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6453           continue;
6454         }
6455
6456       /* Check this method against all the other implementations it
6457          overrides.  Here we only check the class hierarchy; the rest
6458          of the checking is done later.  If this method is just a
6459          Miranda method, we can skip the check.  */
6460       if (! METHOD_INVISIBLE (method))
6461         check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6462     }
6463
6464   /* The above throws clause check only looked at superclasses.  Now
6465      we must also make sure that all methods declared in interfaces
6466      have compatible throws clauses.  FIXME: there are more efficient
6467      ways to organize this checking; we should implement one.  */
6468   check_interface_throws_clauses (class, class);
6469
6470   if (!TYPE_NVIRTUALS (class))
6471     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6472
6473   /* Search for inherited abstract method not yet implemented in this
6474      class.  */
6475   java_check_abstract_method_definitions (class_decl);
6476
6477   if (!saw_constructor)
6478     abort ();
6479 }
6480
6481 /* Check to make sure that all the methods in all the interfaces
6482    implemented by CLASS_DECL are compatible with the concrete
6483    implementations available in CHECK_CLASS_DECL.  */
6484 static void
6485 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6486 {
6487   for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6488     {
6489       tree bases;
6490       int iface_len;
6491       int i;
6492
6493       if (! CLASS_LOADED_P (class_decl))
6494         {
6495           if (CLASS_FROM_SOURCE_P (class_decl))
6496             safe_layout_class (class_decl);
6497           else
6498             load_class (class_decl, 1);
6499         }
6500
6501       bases = TYPE_BINFO_BASETYPES (class_decl);
6502       iface_len = TREE_VEC_LENGTH (bases) - 1;
6503       for (i = iface_len; i > 0; --i)
6504         {
6505           tree interface = BINFO_TYPE (TREE_VEC_ELT (bases, i));
6506           tree iface_method;
6507
6508           for (iface_method = TYPE_METHODS (interface);
6509                iface_method != NULL_TREE;
6510                iface_method = TREE_CHAIN (iface_method))
6511             {
6512               tree sig, method;
6513
6514               /* First look for a concrete method implemented or
6515                  inherited by this class.  No need to search
6516                  interfaces here, since we're already looking through
6517                  all of them.  */
6518               sig = build_java_argument_signature (TREE_TYPE (iface_method));
6519               method
6520                 = lookup_argument_method_generic (check_class_decl,
6521                                                   DECL_NAME (iface_method),
6522                                                   sig, SEARCH_VISIBLE);
6523               /* If we don't find an implementation, that is ok.  Any
6524                  potential errors from that are diagnosed elsewhere.
6525                  Also, multiple inheritance with conflicting throws
6526                  clauses is fine in the absence of a concrete
6527                  implementation.  */
6528               if (method != NULL_TREE && !METHOD_ABSTRACT (method)
6529                   && !METHOD_INVISIBLE (iface_method))
6530                 {
6531                   tree method_wfl = DECL_FUNCTION_WFL (method);
6532                   check_throws_clauses (method, method_wfl, iface_method);
6533                 }
6534             }
6535
6536           /* Now check superinterfaces.  */
6537           check_interface_throws_clauses (check_class_decl, interface);
6538         }
6539     }
6540 }
6541
6542 /* Check throws clauses of a method against the clauses of all the
6543    methods it overrides.  We do this by searching up the class
6544    hierarchy, examining all matching accessible methods.  */
6545 static void
6546 check_concrete_throws_clauses (tree class, tree self_method,
6547                                tree name, tree signature)
6548 {
6549   tree method = lookup_argument_method_generic (class, name, signature,
6550                                                 SEARCH_SUPER | SEARCH_VISIBLE);
6551   while (method != NULL_TREE)
6552     {
6553       if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6554         check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6555                               method);
6556
6557       method = lookup_argument_method_generic (DECL_CONTEXT (method),
6558                                                name, signature,
6559                                                SEARCH_SUPER | SEARCH_VISIBLE);
6560     }
6561 }
6562
6563 /* Generate an error if the `throws' clause of METHOD (if any) is
6564    incompatible with the `throws' clause of FOUND (if any).  */
6565 static void
6566 check_throws_clauses (tree method, tree method_wfl, tree found)
6567 {
6568   tree mthrows;
6569
6570   /* Can't check these things with class loaded from bytecode. FIXME */
6571   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6572     return;
6573
6574   for (mthrows = DECL_FUNCTION_THROWS (method);
6575        mthrows; mthrows = TREE_CHAIN (mthrows))
6576     {
6577       tree fthrows;
6578
6579       /* We don't verify unchecked expressions */
6580       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6581         continue;
6582       /* Checked expression must be compatible */
6583       for (fthrows = DECL_FUNCTION_THROWS (found);
6584            fthrows; fthrows = TREE_CHAIN (fthrows))
6585         {
6586           if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6587             break;
6588         }
6589       if (!fthrows)
6590         {
6591           parse_error_context
6592             (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'",
6593              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6594              lang_printable_name (found, 0),
6595              IDENTIFIER_POINTER
6596              (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6597         }
6598     }
6599 }
6600
6601 /* Check abstract method of interface INTERFACE */
6602 static void
6603 java_check_abstract_methods (tree interface_decl)
6604 {
6605   int i, n;
6606   tree method, basetype_vec, found;
6607   tree interface = TREE_TYPE (interface_decl);
6608
6609   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6610     {
6611       /* 2- Check for double definition inside the defining interface */
6612       if (check_method_redefinition (interface, method))
6613         continue;
6614
6615       /* 3- Overriding is OK as far as we preserve the return type.  */
6616       found = lookup_java_interface_method2 (interface, method);
6617       if (found)
6618         {
6619           char *t;
6620           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6621           parse_error_context
6622             (DECL_FUNCTION_WFL (found),
6623              "Method `%s' was defined with return type `%s' in class `%s'",
6624              lang_printable_name (found, 0), t,
6625              IDENTIFIER_POINTER
6626                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6627           free (t);
6628           continue;
6629         }
6630     }
6631
6632   /* 4- Inherited methods can't differ by their returned types */
6633   if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6634     return;
6635   n = TREE_VEC_LENGTH (basetype_vec);
6636   for (i = 0; i < n; i++)
6637     {
6638       tree sub_interface_method, sub_interface;
6639       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6640       if (!vec_elt)
6641         continue;
6642       sub_interface = BINFO_TYPE (vec_elt);
6643       for (sub_interface_method = TYPE_METHODS (sub_interface);
6644            sub_interface_method;
6645            sub_interface_method = TREE_CHAIN (sub_interface_method))
6646         {
6647           found = lookup_java_interface_method2 (interface,
6648                                                  sub_interface_method);
6649           if (found && (found != sub_interface_method))
6650             {
6651               parse_error_context
6652                 (lookup_cl (sub_interface_method),
6653                  "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6654                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6655                  lang_printable_name (found, 0),
6656                  IDENTIFIER_POINTER
6657                    (DECL_NAME (TYPE_NAME
6658                                (DECL_CONTEXT (sub_interface_method)))),
6659                  IDENTIFIER_POINTER
6660                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6661             }
6662         }
6663     }
6664 }
6665
6666 /* Lookup methods in interfaces using their name and partial
6667    signature. Return a matching method only if their types differ.  */
6668
6669 static tree
6670 lookup_java_interface_method2 (tree class, tree method_decl)
6671 {
6672   int i, n;
6673   tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6674
6675   if (!basetype_vec)
6676     return NULL_TREE;
6677
6678   n = TREE_VEC_LENGTH (basetype_vec);
6679   for (i = 0; i < n; i++)
6680     {
6681       tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6682       if ((BINFO_TYPE (vec_elt) != object_type_node)
6683           && (to_return =
6684               lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6685         return to_return;
6686     }
6687   for (i = 0; i < n; i++)
6688     {
6689       to_return = lookup_java_interface_method2
6690         (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6691       if (to_return)
6692         return to_return;
6693     }
6694
6695   return NULL_TREE;
6696 }
6697
6698 /* Lookup method using their name and partial signature. Return a
6699    matching method only if their types differ.  */
6700
6701 static tree
6702 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6703 {
6704   tree method, method_signature, method_name, method_type, name;
6705
6706   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6707   name = DECL_NAME (method_decl);
6708   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6709                  EXPR_WFL_NODE (name) : name);
6710   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6711
6712   while (clas != NULL_TREE)
6713     {
6714       for (method = TYPE_METHODS (clas);
6715            method != NULL_TREE;  method = TREE_CHAIN (method))
6716         {
6717           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6718           tree name = DECL_NAME (method);
6719           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6720                EXPR_WFL_NODE (name) : name) == method_name
6721               && method_sig == method_signature
6722               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6723             return method;
6724         }
6725       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6726     }
6727   return NULL_TREE;
6728 }
6729
6730 /* Return the line that matches DECL line number, and try its best to
6731    position the column number. Used during error reports.  */
6732
6733 static GTY(()) tree cl_v;
6734 static tree
6735 lookup_cl (tree decl)
6736 {
6737   char *line, *found;
6738
6739   if (!decl)
6740     return NULL_TREE;
6741
6742   if (cl_v == NULL_TREE)
6743     {
6744       cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6745     }
6746
6747   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6748   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6749
6750   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6751                             EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6752
6753   found = strstr ((const char *)line,
6754                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6755   if (found)
6756     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6757
6758   return cl_v;
6759 }
6760
6761 /* Look for a simple name in the single-type import list */
6762
6763 static tree
6764 find_name_in_single_imports (tree name)
6765 {
6766   tree node;
6767
6768   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6769     if (TREE_VALUE (node) == name)
6770       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6771
6772   return NULL_TREE;
6773 }
6774
6775 /* Process all single-type import. */
6776
6777 static int
6778 process_imports (void)
6779 {
6780   tree import;
6781   int error_found;
6782
6783   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6784     {
6785       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6786       char *original_name;
6787
6788       original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6789                                IDENTIFIER_LENGTH (to_be_found),
6790                                IDENTIFIER_LENGTH (to_be_found) + 1);
6791
6792       /* Don't load twice something already defined. */
6793       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6794         continue;
6795
6796       while (1)
6797         {
6798           tree left;
6799
6800           QUALIFIED_P (to_be_found) = 1;
6801           load_class (to_be_found, 0);
6802           error_found =
6803             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true);
6804
6805           /* We found it, we can bail out */
6806           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6807             {
6808               check_deprecation (TREE_PURPOSE (import),
6809                                  IDENTIFIER_CLASS_VALUE (to_be_found));
6810               break;
6811             }
6812
6813           /* We haven't found it. Maybe we're trying to access an
6814              inner class.  The only way for us to know is to try again
6815              after having dropped a qualifier. If we can't break it further,
6816              we have an error. */
6817           if (breakdown_qualified (&left, NULL, to_be_found))
6818             break;
6819
6820           to_be_found = left;
6821         }
6822       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6823         {
6824           parse_error_context (TREE_PURPOSE (import),
6825                                "Class or interface `%s' not found in import",
6826                                original_name);
6827           error_found = 1;
6828         }
6829
6830       free (original_name);
6831       if (error_found)
6832         return 1;
6833     }
6834   return 0;
6835 }
6836
6837 /* Possibly find and mark a class imported by a single-type import
6838    statement.  */
6839
6840 static void
6841 find_in_imports (tree enclosing_type, tree class_type)
6842 {
6843   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6844                  ctxp->import_list);
6845   while (import)
6846     {
6847       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6848         {
6849           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6850           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6851           return;
6852         }
6853       import = TREE_CHAIN (import);
6854     }
6855 }
6856
6857 static int
6858 note_possible_classname (const char *name, int len)
6859 {
6860   tree node;
6861   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6862     len = len - 5;
6863   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6864     len = len - 6;
6865   else
6866     return 0;
6867   node = ident_subst (name, len, "", '/', '.', "");
6868   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6869   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6870   return 1;
6871 }
6872
6873 /* Read a import directory, gathering potential match for further type
6874    references. Indifferently reads a filesystem or a ZIP archive
6875    directory.  */
6876
6877 static void
6878 read_import_dir (tree wfl)
6879 {
6880   tree package_id = EXPR_WFL_NODE (wfl);
6881   const char *package_name = IDENTIFIER_POINTER (package_id);
6882   int package_length = IDENTIFIER_LENGTH (package_id);
6883   DIR *dirp = NULL;
6884   JCF *saved_jcf = current_jcf;
6885
6886   int found = 0;
6887   int k;
6888   void *entry;
6889   struct buffer filename[1];
6890
6891   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6892     return;
6893   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6894
6895   BUFFER_INIT (filename);
6896   buffer_grow (filename, package_length + 100);
6897
6898   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6899     {
6900       const char *entry_name = jcf_path_name (entry);
6901       int entry_length = strlen (entry_name);
6902       if (jcf_path_is_zipfile (entry))
6903         {
6904           ZipFile *zipf;
6905           buffer_grow (filename, entry_length);
6906           memcpy (filename->data, entry_name, entry_length - 1);
6907           filename->data[entry_length-1] = '\0';
6908           zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6909           if (zipf == NULL)
6910             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6911           else
6912             {
6913               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6914               BUFFER_RESET (filename);
6915               for (k = 0; k < package_length; k++)
6916                 {
6917                   char ch = package_name[k];
6918                   *filename->ptr++ = ch == '.' ? '/' : ch;
6919                 }
6920               *filename->ptr++ = '/';
6921
6922               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
6923                 {
6924                   const char *current_entry = ZIPDIR_FILENAME (zipd);
6925                   int current_entry_len = zipd->filename_length;
6926
6927                   if (current_entry_len >= BUFFER_LENGTH (filename)
6928                       && strncmp (filename->data, current_entry,
6929                                   BUFFER_LENGTH (filename)) != 0)
6930                     continue;
6931                   found |= note_possible_classname (current_entry,
6932                                                     current_entry_len);
6933                 }
6934             }
6935         }
6936       else
6937         {
6938           BUFFER_RESET (filename);
6939           buffer_grow (filename, entry_length + package_length + 4);
6940           strcpy (filename->data, entry_name);
6941           filename->ptr = filename->data + entry_length;
6942           for (k = 0; k < package_length; k++)
6943             {
6944               char ch = package_name[k];
6945               *filename->ptr++ = ch == '.' ? '/' : ch;
6946             }
6947           *filename->ptr = '\0';
6948
6949           dirp = opendir (filename->data);
6950           if (dirp == NULL)
6951             continue;
6952           *filename->ptr++ = '/';
6953           for (;;)
6954             {
6955               int len;
6956               const char *d_name;
6957               struct dirent *direntp = readdir (dirp);
6958               if (!direntp)
6959                 break;
6960               d_name = direntp->d_name;
6961               len = strlen (direntp->d_name);
6962               buffer_grow (filename, len+1);
6963               strcpy (filename->ptr, d_name);
6964               found |= note_possible_classname (filename->data + entry_length,
6965                                                 package_length+len+1);
6966             }
6967           if (dirp)
6968             closedir (dirp);
6969         }
6970     }
6971
6972   free (filename->data);
6973
6974   /* Here we should have a unified way of retrieving an entry, to be
6975      indexed. */
6976   if (!found)
6977     {
6978       static int first = 1;
6979       if (first)
6980         {
6981           error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
6982           java_error_count++;
6983           first = 0;
6984         }
6985       else
6986         parse_error_context (wfl, "Package `%s' not found in import",
6987                              package_name);
6988       current_jcf = saved_jcf;
6989       return;
6990     }
6991   current_jcf = saved_jcf;
6992 }
6993
6994 /* Possibly find a type in the import on demands specified
6995    types. Returns 1 if an error occurred, 0 otherwise. Run through the
6996    entire list, to detected potential double definitions.  */
6997
6998 static int
6999 find_in_imports_on_demand (tree enclosing_type, tree class_type)
7000 {
7001   tree class_type_name = TYPE_NAME (class_type);
7002   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
7003                   ctxp->import_demand_list);
7004   tree cl = NULL_TREE;
7005   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
7006   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
7007   tree node;
7008
7009   for (; import; import = TREE_CHAIN (import))
7010     {
7011       int saved_lineno = input_line;
7012       int access_check;
7013       const char *id_name;
7014       tree decl, type_name_copy;
7015
7016       obstack_grow (&temporary_obstack,
7017                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
7018                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
7019       obstack_1grow (&temporary_obstack, '.');
7020       obstack_grow0 (&temporary_obstack,
7021                      IDENTIFIER_POINTER (class_type_name),
7022                      IDENTIFIER_LENGTH (class_type_name));
7023       id_name = obstack_finish (&temporary_obstack);
7024
7025       if (! (node = maybe_get_identifier (id_name)))
7026         continue;
7027
7028       /* Setup lineno so that it refers to the line of the import (in
7029          case we parse a class file and encounter errors */
7030       input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
7031
7032       type_name_copy = TYPE_NAME (class_type);
7033       TYPE_NAME (class_type) = node;
7034       QUALIFIED_P (node) = 1;
7035       decl = IDENTIFIER_CLASS_VALUE (node);
7036       access_check = -1;
7037       /* If there is no DECL set for the class or if the class isn't
7038          loaded and not seen in source yet, then load */
7039       if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
7040                     && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
7041         {
7042           load_class (node, 0);
7043           decl = IDENTIFIER_CLASS_VALUE (node);
7044         }
7045       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7046         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7047                                                false);
7048       else
7049         /* 6.6.1: Inner classes are subject to member access rules. */
7050         access_check = 0;
7051
7052       input_line = saved_lineno;
7053
7054       /* If the loaded class is not accessible or couldn't be loaded,
7055          we restore the original TYPE_NAME and process the next
7056          import. */
7057       if (access_check || !decl)
7058         {
7059           TYPE_NAME (class_type) = type_name_copy;
7060           continue;
7061         }
7062
7063       /* If the loaded class is accessible, we keep a tab on it to
7064          detect and report multiple inclusions. */
7065       if (IS_A_CLASSFILE_NAME (node))
7066         {
7067           if (seen_once < 0)
7068             {
7069               cl = TREE_PURPOSE (import);
7070               seen_once = 1;
7071             }
7072           else if (seen_once >= 0)
7073             {
7074               tree location = (cl ? cl : TREE_PURPOSE (import));
7075               tree package = (cl ? EXPR_WFL_NODE (cl) :
7076                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
7077               seen_once++;
7078               parse_error_context
7079                 (location,
7080                  "Type `%s' also potentially defined in package `%s'",
7081                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7082                  IDENTIFIER_POINTER (package));
7083             }
7084         }
7085       to_return = access_check;
7086     }
7087
7088   if (seen_once == 1)
7089     return to_return;
7090   else
7091     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7092 }
7093
7094 /* Add package NAME to the list of packages encountered so far. To
7095    speed up class lookup in do_resolve_class, we make sure a
7096    particular package is added only once.  */
7097
7098 static void
7099 register_package (tree name)
7100 {
7101   static htab_t pht;
7102   void **e;
7103
7104   if (pht == NULL)
7105     pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
7106
7107   e = htab_find_slot (pht, name, INSERT);
7108   if (*e == NULL)
7109     {
7110       package_list = chainon (package_list, build_tree_list (name, NULL));
7111       *e = name;
7112     }
7113 }
7114
7115 static tree
7116 resolve_package (tree pkg, tree *next, tree *type_name)
7117 {
7118   tree current;
7119   tree decl = NULL_TREE;
7120   *type_name = NULL_TREE;
7121
7122   /* The trick is to determine when the package name stops and were
7123      the name of something contained in the package starts. Then we
7124      return a fully qualified name of what we want to get. */
7125
7126   *next = EXPR_WFL_QUALIFICATION (pkg);
7127
7128   /* Try to progressively construct a type name */
7129   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7130     for (current = EXPR_WFL_QUALIFICATION (pkg);
7131          current; current = TREE_CHAIN (current))
7132       {
7133         /* If we don't have what we're expecting, exit now. TYPE_NAME
7134            will be null and the error caught later. */
7135         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7136           break;
7137         *type_name =
7138           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7139         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7140           {
7141             /* resolve_package should be used in a loop, hence we
7142                point at this one to naturally process the next one at
7143                the next iteration. */
7144             *next = current;
7145             break;
7146           }
7147       }
7148   return decl;
7149 }
7150
7151
7152 /* Check accessibility of inner classes according to member access rules.
7153    DECL is the inner class, ENCLOSING_DECL is the class from which the
7154    access is being attempted. */
7155
7156 static void
7157 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7158 {
7159   const char *access;
7160   tree enclosing_decl_type;
7161
7162   /* We don't issue an error message when CL is null. CL can be null
7163      as a result of processing a JDEP crafted by source_start_java_method
7164      for the purpose of patching its parm decl. But the error would
7165      have been already trapped when fixing the method's signature.
7166      DECL can also be NULL in case of earlier errors. */
7167   if (!decl || !cl)
7168     return;
7169
7170   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7171
7172   if (CLASS_PRIVATE (decl))
7173     {
7174       /* Access is permitted only within the body of the top-level
7175          class in which DECL is declared. */
7176       tree top_level = decl;
7177       while (DECL_CONTEXT (top_level))
7178         top_level = DECL_CONTEXT (top_level);
7179       while (DECL_CONTEXT (enclosing_decl))
7180         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7181       if (top_level == enclosing_decl)
7182         return;
7183       access = "private";
7184     }
7185   else if (CLASS_PROTECTED (decl))
7186     {
7187       tree decl_context;
7188       /* Access is permitted from within the same package... */
7189       if (in_same_package (decl, enclosing_decl))
7190         return;
7191
7192       /* ... or from within the body of a subtype of the context in which
7193          DECL is declared. */
7194       decl_context = DECL_CONTEXT (decl);
7195       while (enclosing_decl)
7196         {
7197           if (CLASS_INTERFACE (decl))
7198             {
7199               if (interface_of_p (TREE_TYPE (decl_context),
7200                                   enclosing_decl_type))
7201                 return;
7202             }
7203           else
7204             {
7205               /* Eww. The order of the arguments is different!! */
7206               if (inherits_from_p (enclosing_decl_type,
7207                                    TREE_TYPE (decl_context)))
7208                 return;
7209             }
7210           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7211         }
7212       access = "protected";
7213     }
7214   else if (! CLASS_PUBLIC (decl))
7215     {
7216       /* Access is permitted only from within the same package as DECL. */
7217       if (in_same_package (decl, enclosing_decl))
7218         return;
7219       access = "non-public";
7220     }
7221   else
7222     /* Class is public. */
7223     return;
7224
7225   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7226                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7227                        lang_printable_name (decl, 0), access);
7228 }
7229
7230 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7231    foreign package, it must be PUBLIC. Return 0 if no access
7232    violations were found, 1 otherwise. If VERBOSE is true and an error
7233    was found, it is reported and accounted for.  */
7234
7235 static int
7236 check_pkg_class_access (tree class_name, tree cl, bool verbose)
7237 {
7238   tree type;
7239
7240   if (!IDENTIFIER_CLASS_VALUE (class_name))
7241     return 0;
7242
7243   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7244     return 0;
7245
7246   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7247     {
7248       /* Access to a private class within the same package is
7249          allowed. */
7250       tree l, r;
7251       breakdown_qualified (&l, &r, class_name);
7252       if (!QUALIFIED_P (class_name) && !ctxp->package)
7253         /* Both in the empty package. */
7254         return 0;
7255       if (l == ctxp->package)
7256         /* Both in the same package. */
7257         return 0;
7258
7259       if (verbose)
7260         parse_error_context
7261           (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7262            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7263            IDENTIFIER_POINTER (class_name));
7264       return 1;
7265     }
7266   return 0;
7267 }
7268
7269 /* Local variable declaration. */
7270
7271 static void
7272 declare_local_variables (int modifier, tree type, tree vlist)
7273 {
7274   tree decl, current, saved_type;
7275   tree type_wfl = NULL_TREE;
7276   int must_chain = 0;
7277   int final_p = 0;
7278
7279   /* Push a new block if statements were seen between the last time we
7280      pushed a block and now. Keep a count of blocks to close */
7281   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7282     {
7283       tree b = enter_block ();
7284       BLOCK_IS_IMPLICIT (b) = 1;
7285     }
7286
7287   if (modifier)
7288     {
7289       size_t i;
7290       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7291         if (1 << i & modifier)
7292           break;
7293       if (modifier == ACC_FINAL)
7294         final_p = 1;
7295       else
7296         {
7297           parse_error_context
7298             (ctxp->modifier_ctx [i],
7299              "Only `final' is allowed as a local variables modifier");
7300           return;
7301         }
7302     }
7303
7304   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7305      hold the TYPE value if a new incomplete has to be created (as
7306      opposed to being found already existing and reused). */
7307   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7308
7309   /* If TYPE is fully resolved and we don't have a reference, make one */
7310   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7311
7312   /* Go through all the declared variables */
7313   for (current = vlist, saved_type = type; current;
7314        current = TREE_CHAIN (current), type = saved_type)
7315     {
7316       tree other, real_type;
7317       tree wfl  = TREE_PURPOSE (current);
7318       tree name = EXPR_WFL_NODE (wfl);
7319       tree init = TREE_VALUE (current);
7320
7321       /* Process NAME, as it may specify extra dimension(s) for it */
7322       type = build_array_from_name (type, type_wfl, name, &name);
7323
7324       /* Variable redefinition check */
7325       if ((other = lookup_name_in_blocks (name)))
7326         {
7327           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7328                                        DECL_SOURCE_LINE (other));
7329           continue;
7330         }
7331
7332       /* Type adjustment. We may have just readjusted TYPE because
7333          the variable specified more dimensions. Make sure we have
7334          a reference if we can and don't have one already. */
7335       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7336
7337       real_type = GET_REAL_TYPE (type);
7338       /* Never layout this decl. This will be done when its scope
7339          will be entered */
7340       decl = build_decl (VAR_DECL, name, real_type);
7341       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7342       DECL_FINAL (decl) = final_p;
7343       BLOCK_CHAIN_DECL (decl);
7344
7345       /* If doing xreferencing, replace the line number with the WFL
7346          compound value */
7347       if (flag_emit_xref)
7348         DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7349
7350       /* Don't try to use an INIT statement when an error was found */
7351       if (init && java_error_count)
7352         init = NULL_TREE;
7353
7354       /* Add the initialization function to the current function's code */
7355       if (init)
7356         {
7357           /* Name might have been readjusted */
7358           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7359           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7360           java_method_add_stmt (current_function_decl,
7361                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7362                                                       init));
7363         }
7364
7365       /* Setup dependency the type of the decl */
7366       if (must_chain)
7367         {
7368           jdep *dep;
7369           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7370           dep = CLASSD_LAST (ctxp->classd_list);
7371           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7372         }
7373     }
7374   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7375 }
7376
7377 /* Called during parsing. Build decls from argument list.  */
7378
7379 static void
7380 source_start_java_method (tree fndecl)
7381 {
7382   tree tem;
7383   tree parm_decl;
7384   int i;
7385
7386   if (!fndecl)
7387     return;
7388
7389   current_function_decl = fndecl;
7390
7391   /* New scope for the function */
7392   enter_block ();
7393   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7394        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7395     {
7396       tree type = TREE_VALUE (tem);
7397       tree name = TREE_PURPOSE (tem);
7398
7399       /* If type is incomplete. Create an incomplete decl and ask for
7400          the decl to be patched later */
7401       if (INCOMPLETE_TYPE_P (type))
7402         {
7403           jdep *jdep;
7404           tree real_type = GET_REAL_TYPE (type);
7405           parm_decl = build_decl (PARM_DECL, name, real_type);
7406           type = obtain_incomplete_type (type);
7407           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7408           jdep = CLASSD_LAST (ctxp->classd_list);
7409           JDEP_MISC (jdep) = name;
7410           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7411         }
7412       else
7413         parm_decl = build_decl (PARM_DECL, name, type);
7414
7415       /* Remember if a local variable was declared final (via its
7416          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7417       if (ARG_FINAL_P (tem))
7418         {
7419           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7420           DECL_FINAL (parm_decl) = 1;
7421         }
7422
7423       BLOCK_CHAIN_DECL (parm_decl);
7424     }
7425   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7426   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7427     nreverse (tem);
7428   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7429   DECL_MAX_LOCALS (current_function_decl) = i;
7430 }
7431
7432 /* Called during parsing. Creates an artificial method declaration.  */
7433
7434 static tree
7435 create_artificial_method (tree class, int flags, tree type,
7436                           tree name, tree args)
7437 {
7438   tree mdecl;
7439
7440   java_parser_context_save_global ();
7441   input_line = 0;
7442   mdecl = make_node (FUNCTION_TYPE);
7443   TREE_TYPE (mdecl) = type;
7444   TYPE_ARG_TYPES (mdecl) = args;
7445   mdecl = add_method (class, flags, name, build_java_signature (mdecl));
7446   java_parser_context_restore_global ();
7447   DECL_ARTIFICIAL (mdecl) = 1;
7448   return mdecl;
7449 }
7450
7451 /* Starts the body if an artificial method.  */
7452
7453 static void
7454 start_artificial_method_body (tree mdecl)
7455 {
7456   DECL_SOURCE_LINE (mdecl) = 1;
7457   DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7458   source_start_java_method (mdecl);
7459   enter_block ();
7460 }
7461
7462 static void
7463 end_artificial_method_body (tree mdecl)
7464 {
7465   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7466      It has to be evaluated first. (if mdecl is current_function_decl,
7467      we have an undefined behavior if no temporary variable is used.) */
7468   tree b = exit_block ();
7469   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7470   exit_block ();
7471 }
7472
7473 /* Dump a tree of some kind.  This is a convenience wrapper for the
7474    dump_* functions in tree-dump.c.  */
7475 static void
7476 dump_java_tree (enum tree_dump_index phase, tree t)
7477 {
7478   FILE *stream;
7479   int flags;
7480
7481   stream = dump_begin (phase, &flags);
7482   flags |= TDF_SLIM;
7483   if (stream)
7484     {
7485       dump_node (t, flags, stream);
7486       dump_end (phase, stream);
7487     }
7488 }
7489
7490 /* Terminate a function and expand its body.  */
7491
7492 static void
7493 source_end_java_method (void)
7494 {
7495   tree fndecl = current_function_decl;
7496
7497   if (!fndecl)
7498     return;
7499
7500   java_parser_context_save_global ();
7501   input_line = ctxp->last_ccb_indent1;
7502
7503   /* Turn function bodies with only a NOP expr null, so they don't get
7504      generated at all and we won't get warnings when using the -W
7505      -Wall flags. */
7506   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
7507     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7508
7509   /* We've generated all the trees for this function, and it has been
7510      patched.  Dump it to a file if the user requested it.  */
7511   dump_java_tree (TDI_original, fndecl);
7512
7513   /* Defer expanding the method until cgraph analysis is complete.  */
7514   if (DECL_SAVED_TREE (fndecl))
7515     cgraph_finalize_function (fndecl, false);
7516
7517   current_function_decl = NULL_TREE;
7518   java_parser_context_restore_global ();
7519 }
7520
7521 /* Record EXPR in the current function block. Complements compound
7522    expression second operand if necessary.  */
7523
7524 tree
7525 java_method_add_stmt (tree fndecl, tree expr)
7526 {
7527   if (!GET_CURRENT_BLOCK (fndecl))
7528     return NULL_TREE;
7529   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7530 }
7531
7532 static tree
7533 add_stmt_to_block (tree b, tree type, tree stmt)
7534 {
7535   tree body = BLOCK_EXPR_BODY (b), c;
7536
7537   if (java_error_count)
7538     return body;
7539
7540   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7541     return body;
7542
7543   BLOCK_EXPR_BODY (b) = c;
7544   TREE_SIDE_EFFECTS (c) = 1;
7545   return c;
7546 }
7547
7548 /* Add STMT to EXISTING if possible, otherwise create a new
7549    COMPOUND_EXPR and add STMT to it. */
7550
7551 static tree
7552 add_stmt_to_compound (tree existing, tree type, tree stmt)
7553 {
7554   if (existing)
7555     return build (COMPOUND_EXPR, type, existing, stmt);
7556   else
7557     return stmt;
7558 }
7559
7560 void java_layout_seen_class_methods (void)
7561 {
7562   tree previous_list = all_class_list;
7563   tree end = NULL_TREE;
7564   tree current;
7565
7566   while (1)
7567     {
7568       for (current = previous_list;
7569            current != end; current = TREE_CHAIN (current))
7570         layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
7571
7572       if (previous_list != all_class_list)
7573         {
7574           end = previous_list;
7575           previous_list = all_class_list;
7576         }
7577       else
7578         break;
7579     }
7580 }
7581
7582 static GTY(()) tree stop_reordering;
7583 void
7584 java_reorder_fields (void)
7585 {
7586   tree current;
7587
7588   for (current = gclass_list; current; current = TREE_CHAIN (current))
7589     {
7590       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7591
7592       if (current_class == stop_reordering)
7593         break;
7594
7595       /* Reverse the fields, but leave the dummy field in front.
7596          Fields are already ordered for Object and Class */
7597       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7598           && current_class != class_type_node)
7599       {
7600         /* If the dummy field is there, reverse the right fields and
7601            just layout the type for proper fields offset */
7602         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7603           {
7604             tree fields = TYPE_FIELDS (current_class);
7605             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7606             TYPE_SIZE (current_class) = NULL_TREE;
7607           }
7608         /* We don't have a dummy field, we need to layout the class,
7609            after having reversed the fields */
7610         else
7611           {
7612             TYPE_FIELDS (current_class) =
7613               nreverse (TYPE_FIELDS (current_class));
7614             TYPE_SIZE (current_class) = NULL_TREE;
7615           }
7616       }
7617     }
7618   /* There are cases were gclass_list will be empty. */
7619   if (gclass_list)
7620     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7621 }
7622
7623 /* Layout the methods of all classes loaded in one way or another.
7624    Check methods of source parsed classes. Then reorder the
7625    fields and layout the classes or the type of all source parsed
7626    classes */
7627
7628 void
7629 java_layout_classes (void)
7630 {
7631   tree current;
7632   int save_error_count = java_error_count;
7633
7634   /* Layout the methods of all classes seen so far */
7635   java_layout_seen_class_methods ();
7636   java_parse_abort_on_error ();
7637   all_class_list = NULL_TREE;
7638
7639   /* Then check the methods of all parsed classes */
7640   for (current = gclass_list; current; current = TREE_CHAIN (current))
7641     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7642       java_check_methods (TREE_VALUE (current));
7643   java_parse_abort_on_error ();
7644
7645   for (current = gclass_list; current; current = TREE_CHAIN (current))
7646     {
7647       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7648       layout_class (current_class);
7649
7650       /* Error reported by the caller */
7651       if (java_error_count)
7652         return;
7653     }
7654
7655   /* We might have reloaded classes durign the process of laying out
7656      classes for code generation. We must layout the methods of those
7657      late additions, as constructor checks might use them */
7658   java_layout_seen_class_methods ();
7659   java_parse_abort_on_error ();
7660 }
7661
7662 /* Expand methods in the current set of classes remembered for
7663    generation.  */
7664
7665 static void
7666 java_complete_expand_classes (void)
7667 {
7668   tree current;
7669
7670   do_not_fold = flag_emit_xref;
7671
7672   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7673     if (!INNER_CLASS_DECL_P (current))
7674       java_complete_expand_class (current);
7675 }
7676
7677 /* Expand the methods found in OUTER, starting first by OUTER's inner
7678    classes, if any.  */
7679
7680 static void
7681 java_complete_expand_class (tree outer)
7682 {
7683   tree inner_list;
7684
7685   set_nested_class_simple_name_value (outer, 1); /* Set */
7686
7687   /* We need to go after all inner classes and start expanding them,
7688      starting with most nested ones. We have to do that because nested
7689      classes might add functions to outer classes */
7690
7691   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7692        inner_list; inner_list = TREE_CHAIN (inner_list))
7693     java_complete_expand_class (TREE_PURPOSE (inner_list));
7694
7695   java_complete_expand_methods (outer);
7696   set_nested_class_simple_name_value (outer, 0); /* Reset */
7697 }
7698
7699 /* Expand methods registered in CLASS_DECL. The general idea is that
7700    we expand regular methods first. This allows us get an estimate on
7701    how outer context local alias fields are really used so we can add
7702    to the constructor just enough code to initialize them properly (it
7703    also lets us generate finit$ correctly.) Then we expand the
7704    constructors and then <clinit>.  */
7705
7706 static void
7707 java_complete_expand_methods (tree class_decl)
7708 {
7709   tree clinit, decl, first_decl;
7710
7711   output_class = current_class = TREE_TYPE (class_decl);
7712
7713   /* Pre-expand <clinit> to figure whether we really need it or
7714      not. If we do need it, we pre-expand the static fields so they're
7715      ready to be used somewhere else. <clinit> will be fully expanded
7716      after we processed the constructors. */
7717   first_decl = TYPE_METHODS (current_class);
7718   clinit = maybe_generate_pre_expand_clinit (current_class);
7719
7720   /* Then generate finit$ (if we need to) because constructors will
7721    try to use it.*/
7722   if (TYPE_FINIT_STMT_LIST (current_class))
7723     java_complete_expand_method (generate_finit (current_class));
7724
7725   /* Then generate instinit$ (if we need to) because constructors will
7726      try to use it. */
7727   if (TYPE_II_STMT_LIST (current_class))
7728     java_complete_expand_method (generate_instinit (current_class));
7729
7730   /* Now do the constructors */
7731   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7732     {
7733       int no_body;
7734
7735       if (!DECL_CONSTRUCTOR_P (decl))
7736         continue;
7737
7738       no_body = !DECL_FUNCTION_BODY (decl);
7739       /* Don't generate debug info on line zero when expanding a
7740          generated constructor. */
7741       if (no_body)
7742         restore_line_number_status (1);
7743
7744       java_complete_expand_method (decl);
7745
7746       if (no_body)
7747         restore_line_number_status (0);
7748     }
7749
7750   /* First, do the ordinary methods. */
7751   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7752     {
7753       /* Ctors aren't part of this batch. */
7754       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7755         continue;
7756
7757       /* Skip abstract or native methods -- but do handle native
7758          methods when generating JNI stubs.  */
7759       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7760         {
7761           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7762           continue;
7763         }
7764
7765       if (METHOD_NATIVE (decl))
7766         {
7767           tree body;
7768           current_function_decl = decl;
7769           body = build_jni_stub (decl);
7770           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7771         }
7772
7773       java_complete_expand_method (decl);
7774     }
7775
7776   /* If there is indeed a <clinit>, fully expand it now */
7777   if (clinit)
7778     {
7779       /* Prevent the use of `this' inside <clinit> */
7780       ctxp->explicit_constructor_p = 1;
7781       java_complete_expand_method (clinit);
7782       ctxp->explicit_constructor_p = 0;
7783     }
7784
7785   /* We might have generated a class$ that we now want to expand */
7786   if (TYPE_DOT_CLASS (current_class))
7787     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7788
7789   /* Now verify constructor circularity (stop after the first one we
7790      prove wrong.) */
7791   if (!CLASS_INTERFACE (class_decl))
7792     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7793       if (DECL_CONSTRUCTOR_P (decl)
7794           && verify_constructor_circularity (decl, decl))
7795         break;
7796 }
7797
7798 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7799    safely used in some other methods/constructors.  */
7800
7801 static tree
7802 maybe_generate_pre_expand_clinit (tree class_type)
7803 {
7804   tree current, mdecl;
7805
7806   if (!TYPE_CLINIT_STMT_LIST (class_type))
7807     return NULL_TREE;
7808
7809   /* Go through all static fields and pre expand them */
7810   for (current = TYPE_FIELDS (class_type); current;
7811        current = TREE_CHAIN (current))
7812     if (FIELD_STATIC (current))
7813       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7814
7815   /* Then build the <clinit> method */
7816   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7817                                     clinit_identifier_node, end_params_node);
7818   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7819                        mdecl, NULL_TREE);
7820   start_artificial_method_body (mdecl);
7821
7822   /* We process the list of assignment we produced as the result of
7823      the declaration of initialized static field and add them as
7824      statement to the <clinit> method. */
7825   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7826        current = TREE_CHAIN (current))
7827     {
7828       tree stmt = current;
7829       /* We build the assignment expression that will initialize the
7830          field to its value. There are strict rules on static
7831          initializers (8.5). FIXME */
7832       if (TREE_CODE (stmt) != BLOCK && stmt != empty_stmt_node)
7833         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7834       java_method_add_stmt (mdecl, stmt);
7835     }
7836
7837   end_artificial_method_body (mdecl);
7838
7839   /* Now we want to place <clinit> as the last method (because we need
7840      it at least for interface so that it doesn't interfere with the
7841      dispatch table based lookup. */
7842   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7843     {
7844       current = TREE_CHAIN (TYPE_METHODS (class_type));
7845       TYPE_METHODS (class_type) = current;
7846
7847       while (TREE_CHAIN (current))
7848         current = TREE_CHAIN (current);
7849
7850       TREE_CHAIN (current) = mdecl;
7851       TREE_CHAIN (mdecl) = NULL_TREE;
7852     }
7853
7854   return mdecl;
7855 }
7856
7857 /* Analyzes a method body and look for something that isn't a
7858    MODIFY_EXPR with a constant value.  */
7859
7860 static int
7861 analyze_clinit_body (tree this_class, tree bbody)
7862 {
7863   while (bbody)
7864     switch (TREE_CODE (bbody))
7865       {
7866       case BLOCK:
7867         bbody = BLOCK_EXPR_BODY (bbody);
7868         break;
7869
7870       case EXPR_WITH_FILE_LOCATION:
7871         bbody = EXPR_WFL_NODE (bbody);
7872         break;
7873
7874       case COMPOUND_EXPR:
7875         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
7876           return 1;
7877         bbody = TREE_OPERAND (bbody, 1);
7878         break;
7879
7880       case MODIFY_EXPR:
7881         /* If we're generating to class file and we're dealing with an
7882            array initialization, we return 1 to keep <clinit> */
7883         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
7884             && flag_emit_class_files)
7885           return 1;
7886
7887         /* There are a few cases where we're required to keep
7888            <clinit>:
7889            - If this is an assignment whose operand is not constant,
7890            - If this is an assignment to a non-initialized field,
7891            - If this field is not a member of the current class.
7892         */
7893         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
7894                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
7895                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
7896
7897       default:
7898         return 1;
7899       }
7900   return 0;
7901 }
7902
7903
7904 /* See whether we could get rid of <clinit>. Criteria are: all static
7905    final fields have constant initial values and the body of <clinit>
7906    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7907
7908 static int
7909 maybe_yank_clinit (tree mdecl)
7910 {
7911   tree type, current;
7912   tree fbody, bbody;
7913
7914   if (!DECL_CLINIT_P (mdecl))
7915     return 0;
7916
7917   /* If the body isn't empty, then we keep <clinit>. Note that if
7918      we're emitting classfiles, this isn't enough not to rule it
7919      out. */
7920   fbody = DECL_FUNCTION_BODY (mdecl);
7921   bbody = BLOCK_EXPR_BODY (fbody);
7922   if (bbody && bbody != error_mark_node)
7923     bbody = BLOCK_EXPR_BODY (bbody);
7924   else
7925     return 0;
7926   if (bbody && ! flag_emit_class_files && bbody != empty_stmt_node)
7927     return 0;
7928
7929   type = DECL_CONTEXT (mdecl);
7930   current = TYPE_FIELDS (type);
7931
7932   for (current = (current ? TREE_CHAIN (current) : current);
7933        current; current = TREE_CHAIN (current))
7934     {
7935       tree f_init;
7936
7937       /* We're not interested in non-static fields.  */
7938       if (!FIELD_STATIC (current))
7939         continue;
7940
7941       /* Nor in fields without initializers. */
7942       f_init = DECL_INITIAL (current);
7943       if (f_init == NULL_TREE)
7944         continue;
7945
7946       /* Anything that isn't String or a basic type is ruled out -- or
7947          if we know how to deal with it (when doing things natively) we
7948          should generated an empty <clinit> so that SUID are computed
7949          correctly. */
7950       if (! JSTRING_TYPE_P (TREE_TYPE (current))
7951           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
7952         return 0;
7953
7954       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
7955         return 0;
7956     }
7957
7958   /* Now we analyze the method body and look for something that
7959      isn't a MODIFY_EXPR */
7960   if (bbody != empty_stmt_node && analyze_clinit_body (type, bbody))
7961     return 0;
7962
7963   /* Get rid of <clinit> in the class' list of methods */
7964   if (TYPE_METHODS (type) == mdecl)
7965     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7966   else
7967     for (current = TYPE_METHODS (type); current;
7968          current = TREE_CHAIN (current))
7969       if (TREE_CHAIN (current) == mdecl)
7970         {
7971           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7972           break;
7973         }
7974
7975   return 1;
7976 }
7977
7978 /* Install the argument from MDECL. Suitable to completion and
7979    expansion of mdecl's body.  */
7980
7981 void
7982 start_complete_expand_method (tree mdecl)
7983 {
7984   tree tem;
7985
7986   pushlevel (1);                /* Prepare for a parameter push */
7987   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7988   DECL_ARGUMENTS (mdecl) = tem;
7989
7990   for (; tem; tem = TREE_CHAIN (tem))
7991     {
7992       /* TREE_CHAIN (tem) will change after pushdecl. */
7993       tree next = TREE_CHAIN (tem);
7994       tree type = TREE_TYPE (tem);
7995       if (targetm.calls.promote_prototypes (type)
7996           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
7997           && INTEGRAL_TYPE_P (type))
7998         type = integer_type_node;
7999       DECL_ARG_TYPE (tem) = type;
8000       layout_decl (tem, 0);
8001       pushdecl (tem);
8002       /* Re-install the next so that the list is kept and the loop
8003          advances. */
8004       TREE_CHAIN (tem) = next;
8005     }
8006   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8007   input_line = DECL_SOURCE_LINE (mdecl);
8008   build_result_decl (mdecl);
8009 }
8010
8011
8012 /* Complete and expand a method.  */
8013
8014 static void
8015 java_complete_expand_method (tree mdecl)
8016 {
8017   tree fbody, block_body, exception_copy;
8018
8019   current_function_decl = mdecl;
8020   /* Fix constructors before expanding them */
8021   if (DECL_CONSTRUCTOR_P (mdecl))
8022     fix_constructors (mdecl);
8023
8024   /* Expand functions that have a body */
8025   if (!DECL_FUNCTION_BODY (mdecl))
8026     return;
8027
8028   fbody = DECL_FUNCTION_BODY (mdecl);
8029   block_body = BLOCK_EXPR_BODY (fbody);
8030   exception_copy = NULL_TREE;
8031
8032   current_function_decl = mdecl;
8033
8034   if (! quiet_flag)
8035     fprintf (stderr, " [%s.",
8036              lang_printable_name (DECL_CONTEXT (mdecl), 0));
8037   announce_function (mdecl);
8038   if (! quiet_flag)
8039     fprintf (stderr, "]");
8040
8041   /* Prepare the function for tree completion */
8042   start_complete_expand_method (mdecl);
8043
8044   /* Install the current this */
8045   current_this = (!METHOD_STATIC (mdecl) ?
8046                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8047
8048   /* Purge the `throws' list of unchecked exceptions (we save a copy
8049      of the list and re-install it later.) */
8050   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8051   purge_unchecked_exceptions (mdecl);
8052
8053   /* Install exceptions thrown with `throws' */
8054   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8055
8056   if (block_body != NULL_TREE)
8057     {
8058       block_body = java_complete_tree (block_body);
8059
8060       /* Before we check initialization, attached all class initialization
8061          variable to the block_body */
8062       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8063                      attach_init_test_initialization_flags, block_body);
8064
8065       if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
8066         {
8067           check_for_initialization (block_body, mdecl);
8068
8069           /* Go through all the flags marking the initialization of
8070              static variables and see whether they're definitively
8071              assigned, in which case the type is remembered as
8072              definitively initialized in MDECL. */
8073           if (STATIC_CLASS_INIT_OPT_P ())
8074             {
8075               /* Always register the context as properly initialized in
8076                  MDECL. This used with caution helps removing extra
8077                  initialization of self. */
8078               if (METHOD_STATIC (mdecl))
8079                 {
8080                   *(htab_find_slot
8081                     (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8082                      DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8083                 }
8084             }
8085         }
8086       ctxp->explicit_constructor_p = 0;
8087     }
8088
8089   BLOCK_EXPR_BODY (fbody) = block_body;
8090
8091   /* If we saw a return but couldn't evaluate it properly, we'll have
8092      an error_mark_node here. */
8093   if (block_body != error_mark_node
8094       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8095       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
8096       && !flag_emit_xref)
8097     missing_return_error (current_function_decl);
8098
8099   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8100   maybe_yank_clinit (mdecl);
8101
8102   /* Pop the current level, with special measures if we found errors. */
8103   if (java_error_count)
8104     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8105   poplevel (1, 0, 1);
8106
8107   /* Pop the exceptions and sanity check */
8108   POP_EXCEPTIONS();
8109   if (currently_caught_type_list)
8110     abort ();
8111
8112   /* Restore the copy of the list of exceptions if emitting xrefs. */
8113   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8114 }
8115
8116 /* For with each class for which there's code to generate. */
8117
8118 static void
8119 java_expand_method_bodies (tree class)
8120 {
8121   tree decl;
8122   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8123     {
8124       tree block;
8125       tree body;
8126
8127       if (! DECL_FUNCTION_BODY (decl))
8128         continue;
8129
8130       current_function_decl = decl;
8131
8132       block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8133
8134       if (TREE_CODE (block) != BLOCK)
8135         abort ();
8136
8137       /* Save the function body for inlining.  */
8138       DECL_SAVED_TREE (decl) = block;
8139
8140       body = BLOCK_EXPR_BODY (block);
8141
8142       if (TREE_TYPE (body) == NULL_TREE)
8143         abort ();
8144
8145       /* It's time to assign the variable flagging static class
8146          initialization based on which classes invoked static methods
8147          are definitely initializing. This should be flagged. */
8148       if (STATIC_CLASS_INIT_OPT_P ())
8149         {
8150           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8151           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8152             {
8153               /* Executed for each statement calling a static function.
8154                  LIST is a TREE_LIST whose PURPOSE is the called function
8155                  and VALUE is a compound whose second operand can be patched
8156                  with static class initialization flag assignments.  */
8157
8158               tree called_method = TREE_PURPOSE (list);
8159               tree compound = TREE_VALUE (list);
8160               tree assignment_compound_list
8161                 = build_tree_list (called_method, NULL);
8162
8163               /* For each class definitely initialized in
8164                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8165                  assignment to the class initialization flag. */
8166               htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8167                              emit_test_initialization,
8168                              assignment_compound_list);
8169
8170               if (TREE_VALUE (assignment_compound_list))
8171                 TREE_OPERAND (compound, 1)
8172                   = TREE_VALUE (assignment_compound_list);
8173             }
8174         }
8175
8176       /* Prepend class initialization to static methods.  */
8177       if (METHOD_STATIC (decl) && ! METHOD_PRIVATE (decl)
8178           && ! flag_emit_class_files
8179           && ! DECL_CLINIT_P (decl)
8180           && ! CLASS_INTERFACE (TYPE_NAME (class)))
8181         {
8182           tree init = build (CALL_EXPR, void_type_node,
8183                              build_address_of (soft_initclass_node),
8184                              build_tree_list (NULL_TREE,
8185                                               build_class_ref (class)),
8186                              NULL_TREE);
8187           TREE_SIDE_EFFECTS (init) = 1;
8188           body = build (COMPOUND_EXPR, TREE_TYPE (body), init, body);
8189           BLOCK_EXPR_BODY (block) = body;
8190         }
8191
8192       /* Wrap synchronized method bodies in a monitorenter
8193          plus monitorexit cleanup.  */
8194       if (METHOD_SYNCHRONIZED (decl) && ! flag_emit_class_files)
8195         {
8196           tree enter, exit, lock;
8197           if (METHOD_STATIC (decl))
8198             lock = build_class_ref (class);
8199           else
8200             lock = DECL_ARGUMENTS (decl);
8201           BUILD_MONITOR_ENTER (enter, lock);
8202           BUILD_MONITOR_EXIT (exit, lock);
8203
8204           body = build (COMPOUND_EXPR, void_type_node,
8205                         enter,
8206                         build (TRY_FINALLY_EXPR, void_type_node, body, exit));
8207           BLOCK_EXPR_BODY (block) = body;
8208         }
8209
8210       /* Expand the the function body.  */
8211       source_end_java_method ();
8212     }
8213 }
8214
8215 \f
8216
8217 /* This section of the code deals with accessing enclosing context
8218    fields either directly by using the relevant access to this$<n> or
8219    by invoking an access method crafted for that purpose.  */
8220
8221 /* Build the necessary access from an inner class to an outer
8222    class. This routine could be optimized to cache previous result
8223    (decl, current_class and returned access).  When an access method
8224    needs to be generated, it always takes the form of a read. It might
8225    be later turned into a write by calling outer_field_access_fix.  */
8226
8227 static tree
8228 build_outer_field_access (tree id, tree decl)
8229 {
8230   tree access = NULL_TREE;
8231   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8232   tree decl_ctx = DECL_CONTEXT (decl);
8233
8234   /* If the immediate enclosing context of the current class is the
8235      field decl's class or inherits from it; build the access as
8236      `this$<n>.<field>'. Note that we will break the `private' barrier
8237      if we're not emitting bytecodes. */
8238   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8239       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8240     {
8241       tree thisn = build_current_thisn (current_class);
8242       access = make_qualified_primary (build_wfl_node (thisn),
8243                                        id, EXPR_WFL_LINECOL (id));
8244     }
8245   /* Otherwise, generate access methods to outer this and access the
8246      field (either using an access method or by direct access.) */
8247   else
8248     {
8249       int lc = EXPR_WFL_LINECOL (id);
8250
8251       /* Now we chain the required number of calls to the access$0 to
8252          get a hold to the enclosing instance we need, and then we
8253          build the field access. */
8254       access = build_access_to_thisn (current_class, decl_ctx, lc);
8255
8256       /* If the field is private and we're generating bytecode, then
8257          we generate an access method */
8258       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8259         {
8260           tree name = build_outer_field_access_methods (decl);
8261           access = build_outer_field_access_expr (lc, decl_ctx,
8262                                                   name, access, NULL_TREE);
8263         }
8264       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8265          Once again we break the `private' access rule from a foreign
8266          class. */
8267       else
8268         access = make_qualified_primary (access, id, lc);
8269     }
8270   return resolve_expression_name (access, NULL);
8271 }
8272
8273 /* Return a nonzero value if NODE describes an outer field inner
8274    access.  */
8275
8276 static int
8277 outer_field_access_p (tree type, tree decl)
8278 {
8279   if (!INNER_CLASS_TYPE_P (type)
8280       || TREE_CODE (decl) != FIELD_DECL
8281       || DECL_CONTEXT (decl) == type)
8282     return 0;
8283
8284   /* If the inner class extends the declaration context of the field
8285      we're trying to access, then this isn't an outer field access */
8286   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8287     return 0;
8288
8289   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8290        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8291     {
8292       if (type == DECL_CONTEXT (decl))
8293         return 1;
8294
8295       if (!DECL_CONTEXT (TYPE_NAME (type)))
8296         {
8297           /* Before we give up, see whether the field is inherited from
8298              the enclosing context we're considering. */
8299           if (inherits_from_p (type, DECL_CONTEXT (decl)))
8300             return 1;
8301           break;
8302         }
8303     }
8304
8305   return 0;
8306 }
8307
8308 /* Return a nonzero value if NODE represents an outer field inner
8309    access that was been already expanded. As a side effect, it returns
8310    the name of the field being accessed and the argument passed to the
8311    access function, suitable for a regeneration of the access method
8312    call if necessary. */
8313
8314 static int
8315 outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8316                                tree *arg)
8317 {
8318   int identified = 0;
8319
8320   if (TREE_CODE (node) != CALL_EXPR)
8321     return 0;
8322
8323   /* Well, gcj generates slightly different tree nodes when compiling
8324      to native or bytecodes. It's the case for function calls. */
8325
8326   if (flag_emit_class_files
8327       && TREE_CODE (node) == CALL_EXPR
8328       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8329     identified = 1;
8330   else if (!flag_emit_class_files)
8331     {
8332       node = TREE_OPERAND (node, 0);
8333
8334       if (node && TREE_OPERAND (node, 0)
8335           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8336         {
8337           node = TREE_OPERAND (node, 0);
8338           if (TREE_OPERAND (node, 0)
8339               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8340               && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8341                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8342             identified = 1;
8343         }
8344     }
8345
8346   if (identified && name && arg_type && arg)
8347     {
8348       tree argument = TREE_OPERAND (node, 1);
8349       *name = DECL_NAME (TREE_OPERAND (node, 0));
8350       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8351       *arg = TREE_VALUE (argument);
8352     }
8353   return identified;
8354 }
8355
8356 /* Detect in NODE an outer field read access from an inner class and
8357    transform it into a write with RHS as an argument. This function is
8358    called from the java_complete_lhs when an assignment to a LHS can
8359    be identified. */
8360
8361 static tree
8362 outer_field_access_fix (tree wfl, tree node, tree rhs)
8363 {
8364   tree name, arg_type, arg;
8365
8366   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8367     {
8368       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8369                                             arg_type, name, arg, rhs);
8370       return java_complete_tree (node);
8371     }
8372   return NULL_TREE;
8373 }
8374
8375 /* Construct the expression that calls an access method:
8376      <type>.access$<n>(<arg1> [, <arg2>]);
8377
8378    ARG2 can be NULL and will be omitted in that case. It will denote a
8379    read access.  */
8380
8381 static tree
8382 build_outer_field_access_expr (int lc, tree type, tree access_method_name,
8383                                tree arg1, tree arg2)
8384 {
8385   tree args, cn, access;
8386
8387   args = arg1 ? arg1 :
8388     build_wfl_node (build_current_thisn (current_class));
8389   args = build_tree_list (NULL_TREE, args);
8390
8391   if (arg2)
8392     args = tree_cons (NULL_TREE, arg2, args);
8393
8394   access = build_method_invocation (build_wfl_node (access_method_name), args);
8395   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8396   return make_qualified_primary (cn, access, lc);
8397 }
8398
8399 static tree
8400 build_new_access_id (void)
8401 {
8402   static int access_n_counter = 1;
8403   char buffer [128];
8404
8405   sprintf (buffer, "access$%d", access_n_counter++);
8406   return get_identifier (buffer);
8407 }
8408
8409 /* Create the static access functions for the outer field DECL. We define a
8410    read:
8411      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8412        return inst$.field;
8413      }
8414    and a write access:
8415      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8416                                      TREE_TYPE (<field>) value$) {
8417        return inst$.field = value$;
8418      }
8419    We should have a usage flags on the DECL so we can lazily turn the ones
8420    we're using for code generation. FIXME.
8421 */
8422
8423 static tree
8424 build_outer_field_access_methods (tree decl)
8425 {
8426   tree id, args, stmt, mdecl;
8427
8428   if (FIELD_INNER_ACCESS_P (decl))
8429     return FIELD_INNER_ACCESS (decl);
8430
8431   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8432
8433   /* Create the identifier and a function named after it. */
8434   id = build_new_access_id ();
8435
8436   /* The identifier is marked as bearing the name of a generated write
8437      access function for outer field accessed from inner classes. */
8438   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8439
8440   /* Create the read access */
8441   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8442   TREE_CHAIN (args) = end_params_node;
8443   stmt = make_qualified_primary (build_wfl_node (inst_id),
8444                                  build_wfl_node (DECL_NAME (decl)), 0);
8445   stmt = build_return (0, stmt);
8446   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8447                                            TREE_TYPE (decl), id, args, stmt);
8448   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8449
8450   /* Create the write access method. No write access for final variable */
8451   if (!FIELD_FINAL (decl))
8452     {
8453       args = build_tree_list (inst_id,
8454                               build_pointer_type (DECL_CONTEXT (decl)));
8455       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8456       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8457       stmt = make_qualified_primary (build_wfl_node (inst_id),
8458                                      build_wfl_node (DECL_NAME (decl)), 0);
8459       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8460                                                 build_wfl_node (wpv_id)));
8461       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8462                                                TREE_TYPE (decl), id,
8463                                                args, stmt);
8464     }
8465   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8466
8467   /* Return the access name */
8468   return FIELD_INNER_ACCESS (decl) = id;
8469 }
8470
8471 /* Build an field access method NAME.  */
8472
8473 static tree
8474 build_outer_field_access_method (tree class, tree type, tree name,
8475                                  tree args, tree body)
8476 {
8477   tree saved_current_function_decl, mdecl;
8478
8479   /* Create the method */
8480   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8481   fix_method_argument_names (args, mdecl);
8482   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8483
8484   /* Attach the method body. */
8485   saved_current_function_decl = current_function_decl;
8486   start_artificial_method_body (mdecl);
8487   java_method_add_stmt (mdecl, body);
8488   end_artificial_method_body (mdecl);
8489   current_function_decl = saved_current_function_decl;
8490
8491   return mdecl;
8492 }
8493
8494 \f
8495 /* This section deals with building access function necessary for
8496    certain kinds of method invocation from inner classes.  */
8497
8498 static tree
8499 build_outer_method_access_method (tree decl)
8500 {
8501   tree saved_current_function_decl, mdecl;
8502   tree args = NULL_TREE, call_args = NULL_TREE;
8503   tree carg, id, body, class;
8504   char buffer [80];
8505   int parm_id_count = 0;
8506
8507   /* Test this abort with an access to a private field */
8508   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8509     abort ();
8510
8511   /* Check the cache first */
8512   if (DECL_FUNCTION_INNER_ACCESS (decl))
8513     return DECL_FUNCTION_INNER_ACCESS (decl);
8514
8515   class = DECL_CONTEXT (decl);
8516
8517   /* Obtain an access identifier and mark it */
8518   id = build_new_access_id ();
8519   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8520
8521   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8522   /* Create the arguments, as much as the original */
8523   for (; carg && carg != end_params_node;
8524        carg = TREE_CHAIN (carg))
8525     {
8526       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8527       args = chainon (args, build_tree_list (get_identifier (buffer),
8528                                              TREE_VALUE (carg)));
8529     }
8530   args = chainon (args, end_params_node);
8531
8532   /* Create the method */
8533   mdecl = create_artificial_method (class, ACC_STATIC,
8534                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8535   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8536   /* There is a potential bug here. We should be able to use
8537      fix_method_argument_names, but then arg names get mixed up and
8538      eventually a constructor will have its this$0 altered and the
8539      outer context won't be assignment properly. The testcase is
8540      stub.java FIXME */
8541   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8542
8543   /* Attach the method body. */
8544   saved_current_function_decl = current_function_decl;
8545   start_artificial_method_body (mdecl);
8546
8547   /* The actual method invocation uses the same args. When invoking a
8548      static methods that way, we don't want to skip the first
8549      argument. */
8550   carg = args;
8551   if (!METHOD_STATIC (decl))
8552     carg = TREE_CHAIN (carg);
8553   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8554     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8555                            call_args);
8556
8557   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8558                                   call_args);
8559   if (!METHOD_STATIC (decl))
8560     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8561                                    body, 0);
8562   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8563     body = build_return (0, body);
8564   java_method_add_stmt (mdecl,body);
8565   end_artificial_method_body (mdecl);
8566   current_function_decl = saved_current_function_decl;
8567
8568   /* Back tag the access function so it know what it accesses */
8569   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8570
8571   /* Tag the current method so it knows it has an access generated */
8572   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8573 }
8574
8575 \f
8576 /* This section of the code deals with building expressions to access
8577    the enclosing instance of an inner class. The enclosing instance is
8578    kept in a generated field called this$<n>, with <n> being the
8579    inner class nesting level (starting from 0.)  */
8580
8581 /* Build an access to a given this$<n>, always chaining access call to
8582    others. Access methods to this$<n> are build on the fly if
8583    necessary. This CAN'T be used to solely access this$<n-1> from
8584    this$<n> (which alway yield to special cases and optimization, see
8585    for example build_outer_field_access).  */
8586
8587 static tree
8588 build_access_to_thisn (tree from, tree to, int lc)
8589 {
8590   tree access = NULL_TREE;
8591
8592   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8593     {
8594       if (!access)
8595         {
8596           access = build_current_thisn (from);
8597           access = build_wfl_node (access);
8598         }
8599       else
8600         {
8601           tree access0_wfl, cn;
8602
8603           maybe_build_thisn_access_method (from);
8604           access0_wfl = build_wfl_node (access0_identifier_node);
8605           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8606           EXPR_WFL_LINECOL (access0_wfl) = lc;
8607           access = build_tree_list (NULL_TREE, access);
8608           access = build_method_invocation (access0_wfl, access);
8609           access = make_qualified_primary (cn, access, lc);
8610         }
8611
8612       /* If FROM isn't an inner class, that's fine, we've done enough.
8613          What we're looking for can be accessed from there.  */
8614       from = DECL_CONTEXT (TYPE_NAME (from));
8615       if (!from)
8616         break;
8617       from = TREE_TYPE (from);
8618     }
8619   return access;
8620 }
8621
8622 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8623    is returned if nothing needs to be generated. Otherwise, the method
8624    generated and a method decl is returned.
8625
8626    NOTE: These generated methods should be declared in a class file
8627    attribute so that they can't be referred to directly.  */
8628
8629 static tree
8630 maybe_build_thisn_access_method (tree type)
8631 {
8632   tree mdecl, args, stmt, rtype;
8633   tree saved_current_function_decl;
8634
8635   /* If TYPE is a top-level class, no access method is required.
8636      If there already is such an access method, bail out. */
8637   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8638     return NULL_TREE;
8639
8640   /* We generate the method. The method looks like:
8641      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8642   */
8643   args = build_tree_list (inst_id, build_pointer_type (type));
8644   TREE_CHAIN (args) = end_params_node;
8645   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8646   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8647                                     access0_identifier_node, args);
8648   fix_method_argument_names (args, mdecl);
8649   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8650   stmt = build_current_thisn (type);
8651   stmt = make_qualified_primary (build_wfl_node (inst_id),
8652                                  build_wfl_node (stmt), 0);
8653   stmt = build_return (0, stmt);
8654
8655   saved_current_function_decl = current_function_decl;
8656   start_artificial_method_body (mdecl);
8657   java_method_add_stmt (mdecl, stmt);
8658   end_artificial_method_body (mdecl);
8659   current_function_decl = saved_current_function_decl;
8660
8661   CLASS_ACCESS0_GENERATED_P (type) = 1;
8662
8663   return mdecl;
8664 }
8665
8666 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8667    the first level of innerclassing. this$1 for the next one, etc...
8668    This function can be invoked with TYPE to NULL, available and then
8669    has to count the parser context.  */
8670
8671 static GTY(()) tree saved_thisn;
8672 static GTY(()) tree saved_type;
8673
8674 static tree
8675 build_current_thisn (tree type)
8676 {
8677   static int saved_i = -1;
8678   static int saved_type_i = 0;
8679   tree decl;
8680   char buffer [24];
8681   int i = 0;
8682
8683   if (type)
8684     {
8685       if (type == saved_type)
8686         i = saved_type_i;
8687       else
8688         {
8689           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8690                decl; decl = DECL_CONTEXT (decl), i++)
8691             ;
8692
8693           saved_type = type;
8694           saved_type_i = i;
8695         }
8696     }
8697   else
8698     i = list_length (GET_CPC_LIST ())-2;
8699
8700   if (i == saved_i)
8701     return saved_thisn;
8702
8703   sprintf (buffer, "this$%d", i);
8704   saved_i = i;
8705   saved_thisn = get_identifier (buffer);
8706   return saved_thisn;
8707 }
8708
8709 /* Return the assignment to the hidden enclosing context `this$<n>'
8710    by the second incoming parameter to the innerclass constructor. The
8711    form used is `this.this$<n> = this$<n>;'.  */
8712
8713 static tree
8714 build_thisn_assign (void)
8715 {
8716   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8717     {
8718       tree thisn = build_current_thisn (current_class);
8719       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8720                                          build_wfl_node (thisn), 0);
8721       tree rhs = build_wfl_node (thisn);
8722       EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8723       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8724     }
8725   return NULL_TREE;
8726 }
8727
8728 \f
8729 /* Building the synthetic `class$' used to implement the `.class' 1.1
8730    extension for non primitive types. This method looks like:
8731
8732     static Class class$(String type) throws NoClassDefFoundError
8733     {
8734       try {return (java.lang.Class.forName (String));}
8735       catch (ClassNotFoundException e) {
8736         throw new NoClassDefFoundError(e.getMessage());}
8737     } */
8738
8739 static GTY(()) tree get_message_wfl;
8740 static GTY(()) tree type_parm_wfl;
8741
8742 static tree
8743 build_dot_class_method (tree class)
8744 {
8745 #define BWF(S) build_wfl_node (get_identifier ((S)))
8746 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8747   tree args, tmp, saved_current_function_decl, mdecl, qual_name;
8748   tree stmt, throw_stmt;
8749
8750   if (!get_message_wfl)
8751     {
8752       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8753       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8754     }
8755
8756   /* Build the arguments */
8757   args = build_tree_list (get_identifier ("type$"),
8758                           build_pointer_type (string_type_node));
8759   TREE_CHAIN (args) = end_params_node;
8760
8761   /* Build the qualified name java.lang.Class.forName */
8762   tmp = MQN (MQN (MQN (BWF ("java"),
8763                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8764
8765   /* Create the "class$" function */
8766   mdecl = create_artificial_method (class, ACC_STATIC,
8767                                     build_pointer_type (class_type_node),
8768                                     classdollar_identifier_node, args);
8769   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8770                    BWF ("NoClassDefFoundError"));
8771   DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE, qual_name);
8772   register_incomplete_type (JDEP_EXCEPTION, qual_name, NULL_TREE, NULL_TREE);
8773   JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
8774     &TREE_VALUE (DECL_FUNCTION_THROWS (mdecl));
8775
8776   /* We start by building the try block. We need to build:
8777        return (java.lang.Class.forName (type)); */
8778   stmt = build_method_invocation (tmp,
8779                                   build_tree_list (NULL_TREE, type_parm_wfl));
8780   stmt = build_return (0, stmt);
8781
8782   /* Now onto the catch block. We start by building the expression
8783      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8784   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8785                                     get_message_wfl, 0);
8786   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8787
8788   /* Build new NoClassDefFoundError (_.getMessage) */
8789   throw_stmt = build_new_invocation
8790     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8791      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8792
8793   /* Build the throw, (it's too early to use BUILD_THROW) */
8794   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8795
8796   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8797   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8798                    BWF ("ClassNotFoundException"));
8799   stmt = encapsulate_with_try_catch (0, qual_name, stmt, throw_stmt);
8800
8801   fix_method_argument_names (args, mdecl);
8802   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8803   saved_current_function_decl = current_function_decl;
8804   start_artificial_method_body (mdecl);
8805   java_method_add_stmt (mdecl, stmt);
8806   end_artificial_method_body (mdecl);
8807   current_function_decl = saved_current_function_decl;
8808   TYPE_DOT_CLASS (class) = mdecl;
8809
8810   return mdecl;
8811 }
8812
8813 static tree
8814 build_dot_class_method_invocation (tree this_class, tree type)
8815 {
8816   tree dot_class_method = TYPE_DOT_CLASS (this_class);
8817   tree sig_id, s, t;
8818
8819   if (TYPE_ARRAY_P (type))
8820     sig_id = build_java_signature (type);
8821   else
8822     sig_id = DECL_NAME (TYPE_NAME (type));
8823
8824   /* Ensure that the proper name separator is used */
8825   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8826                                IDENTIFIER_LENGTH (sig_id));
8827
8828   s = build_string (IDENTIFIER_LENGTH (sig_id),
8829                     IDENTIFIER_POINTER (sig_id));
8830   t = build_method_invocation (build_wfl_node (DECL_NAME (dot_class_method)),
8831                                build_tree_list (NULL_TREE, s));
8832   if (DECL_CONTEXT (dot_class_method) != this_class)
8833     {
8834       tree class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (dot_class_method)));
8835       t = make_qualified_primary (build_wfl_node (class_name), t, 0);
8836     }
8837   return t;
8838 }
8839
8840 /* This section of the code deals with constructor.  */
8841
8842 /* Craft a body for default constructor. Patch existing constructor
8843    bodies with call to super() and field initialization statements if
8844    necessary.  */
8845
8846 static void
8847 fix_constructors (tree mdecl)
8848 {
8849   tree iii;                     /* Instance Initializer Invocation */
8850   tree body = DECL_FUNCTION_BODY (mdecl);
8851   tree thisn_assign, compound = NULL_TREE;
8852   tree class_type = DECL_CONTEXT (mdecl);
8853
8854   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8855     return;
8856   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8857
8858   if (!body)
8859     {
8860       /* It is an error for the compiler to generate a default
8861          constructor if the superclass doesn't have a constructor that
8862          takes no argument, or the same args for an anonymous class */
8863       if (verify_constructor_super (mdecl))
8864         {
8865           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8866           tree save = DECL_NAME (mdecl);
8867           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8868           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8869           parse_error_context
8870             (lookup_cl (TYPE_NAME (class_type)),
8871              "No constructor matching `%s' found in class `%s'",
8872              lang_printable_name (mdecl, 0), n);
8873           DECL_NAME (mdecl) = save;
8874         }
8875
8876       /* The constructor body must be crafted by hand. It's the
8877          constructor we defined when we realize we didn't have the
8878          CLASSNAME() constructor */
8879       start_artificial_method_body (mdecl);
8880
8881       /* Insert an assignment to the this$<n> hidden field, if
8882          necessary */
8883       if ((thisn_assign = build_thisn_assign ()))
8884         java_method_add_stmt (mdecl, thisn_assign);
8885
8886       /* We don't generate a super constructor invocation if we're
8887          compiling java.lang.Object. build_super_invocation takes care
8888          of that. */
8889       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8890
8891       /* FIXME */
8892       if ((iii = build_instinit_invocation (class_type)))
8893         java_method_add_stmt (mdecl, iii);
8894
8895       end_artificial_method_body (mdecl);
8896     }
8897   /* Search for an explicit constructor invocation */
8898   else
8899     {
8900       int found = 0;
8901       int invokes_this = 0;
8902       tree found_call = NULL_TREE;
8903       tree main_block = BLOCK_EXPR_BODY (body);
8904
8905       while (body)
8906         switch (TREE_CODE (body))
8907           {
8908           case CALL_EXPR:
8909             found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8910             if (CALL_THIS_CONSTRUCTOR_P (body))
8911               invokes_this = 1;
8912             body = NULL_TREE;
8913             break;
8914           case COMPOUND_EXPR:
8915           case EXPR_WITH_FILE_LOCATION:
8916             found_call = body;
8917             body = TREE_OPERAND (body, 0);
8918             break;
8919           case BLOCK:
8920             found_call = body;
8921             body = BLOCK_EXPR_BODY (body);
8922             break;
8923           default:
8924             found = 0;
8925             body = NULL_TREE;
8926           }
8927
8928       /* Generate the assignment to this$<n>, if necessary */
8929       if ((thisn_assign = build_thisn_assign ()))
8930         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8931
8932       /* The constructor is missing an invocation of super() */
8933       if (!found)
8934         compound = add_stmt_to_compound (compound, NULL_TREE,
8935                                          build_super_invocation (mdecl));
8936       /* Explicit super() invocation should take place before the
8937          instance initializer blocks. */
8938       else
8939         {
8940           compound = add_stmt_to_compound (compound, NULL_TREE,
8941                                            TREE_OPERAND (found_call, 0));
8942           TREE_OPERAND (found_call, 0) = empty_stmt_node;
8943         }
8944
8945       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
8946
8947       /* Insert the instance initializer block right after. */
8948       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
8949         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
8950
8951       /* Fix the constructor main block if we're adding extra stmts */
8952       if (compound)
8953         {
8954           compound = add_stmt_to_compound (compound, NULL_TREE,
8955                                            BLOCK_EXPR_BODY (main_block));
8956           BLOCK_EXPR_BODY (main_block) = compound;
8957         }
8958     }
8959 }
8960
8961 /* Browse constructors in the super class, searching for a constructor
8962    that doesn't take any argument. Return 0 if one is found, 1
8963    otherwise.  If the current class is an anonymous inner class, look
8964    for something that has the same signature. */
8965
8966 static int
8967 verify_constructor_super (tree mdecl)
8968 {
8969   tree class = CLASSTYPE_SUPER (current_class);
8970   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8971   tree sdecl;
8972
8973   if (!class)
8974     return 0;
8975
8976   if (ANONYMOUS_CLASS_P (current_class))
8977     {
8978       tree mdecl_arg_type;
8979       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8980       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8981         if (DECL_CONSTRUCTOR_P (sdecl))
8982           {
8983             tree m_arg_type;
8984             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8985             if (super_inner)
8986               arg_type = TREE_CHAIN (arg_type);
8987             for (m_arg_type = mdecl_arg_type;
8988                  (arg_type != end_params_node
8989                   && m_arg_type != end_params_node);
8990                  arg_type = TREE_CHAIN (arg_type),
8991                    m_arg_type = TREE_CHAIN (m_arg_type))
8992               if (!valid_method_invocation_conversion_p
8993                      (TREE_VALUE (arg_type),
8994                       TREE_VALUE (m_arg_type)))
8995                 break;
8996
8997             if (arg_type == end_params_node && m_arg_type == end_params_node)
8998               return 0;
8999           }
9000     }
9001   else
9002     {
9003       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
9004         {
9005           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
9006           if (super_inner)
9007             arg = TREE_CHAIN (arg);
9008           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
9009             return 0;
9010         }
9011     }
9012   return 1;
9013 }
9014
9015 /* Generate code for all context remembered for code generation.  */
9016
9017 static GTY(()) tree reversed_class_list;
9018 void
9019 java_expand_classes (void)
9020 {
9021   int save_error_count = 0;
9022   static struct parser_ctxt *cur_ctxp = NULL;
9023
9024   java_parse_abort_on_error ();
9025   if (!(ctxp = ctxp_for_generation))
9026     return;
9027   java_layout_classes ();
9028   java_parse_abort_on_error ();
9029
9030   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9031     {
9032       tree current;
9033       for (current = cur_ctxp->class_list;
9034            current;
9035            current = TREE_CHAIN (current))
9036         gen_indirect_dispatch_tables (TREE_TYPE (current));
9037     }
9038
9039   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9040     {
9041       ctxp = cur_ctxp;
9042       input_filename = ctxp->filename;
9043       lang_init_source (2);            /* Error msgs have method prototypes */
9044       java_complete_expand_classes (); /* Complete and expand classes */
9045       java_parse_abort_on_error ();
9046     }
9047   input_filename = main_input_filename;
9048
9049   /* Find anonymous classes and expand their constructor. This extra pass is
9050      necessary because the constructor itself is only generated when the
9051      method in which it is defined is expanded. */
9052   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9053     {
9054       tree current;
9055       ctxp = cur_ctxp;
9056       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9057         {
9058           output_class = current_class = TREE_TYPE (current);
9059           if (ANONYMOUS_CLASS_P (current_class))
9060             {
9061               tree d;
9062               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9063                 {
9064                   if (DECL_CONSTRUCTOR_P (d))
9065                     {
9066                       restore_line_number_status (1);
9067                       java_complete_expand_method (d);
9068                       restore_line_number_status (0);
9069                       break;    /* There is only one constructor. */
9070                     }
9071                 }
9072             }
9073         }
9074     }
9075
9076   /* Expanding the constructors of anonymous classes generates access
9077      methods.  Scan all the methods looking for null DECL_RESULTs --
9078      this will be the case if a method hasn't been expanded.  */
9079   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9080     {
9081       tree current;
9082       ctxp = cur_ctxp;
9083       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9084         {
9085           tree d;
9086           output_class = current_class = TREE_TYPE (current);
9087           for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9088             {
9089               if (DECL_RESULT (d) == NULL_TREE)
9090                 {
9091                   restore_line_number_status (1);
9092                   java_complete_expand_method (d);
9093                   restore_line_number_status (0);
9094                 }
9095             }
9096         }
9097     }
9098
9099   /* ???  Instead of all this we could iterate around the list of
9100      classes until there were no more un-expanded methods.  It would
9101      take a little longer -- one pass over the whole list of methods
9102      -- but it would be simpler.  Like this:  */
9103 #if 0
9104     {
9105       int something_changed;
9106
9107       do
9108         {
9109           something_changed = 0;
9110           for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9111             {
9112               tree current;
9113               ctxp = cur_ctxp;
9114               for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9115                 {
9116                   tree d;
9117                   output_class = current_class = TREE_TYPE (current);
9118                   for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9119                     {
9120                       if (DECL_RESULT (d) == NULL_TREE)
9121                         {
9122                           something_changed = 1;
9123                           restore_line_number_status (1);
9124                           java_complete_expand_method (d);
9125                           restore_line_number_status (0);
9126                         }
9127                     }
9128                 }
9129             }
9130         }
9131       while (something_changed);
9132     }
9133 #endif
9134
9135   /* If we've found error at that stage, don't try to generate
9136      anything, unless we're emitting xrefs or checking the syntax only
9137      (but not using -fsyntax-only for the purpose of generating
9138      bytecode. */
9139   if (java_error_count && !flag_emit_xref
9140       && (!flag_syntax_only && !flag_emit_class_files))
9141     return;
9142
9143   /* Now things are stable, go for generation of the class data. */
9144
9145   /* We pessimistically marked all methods and fields external until
9146      we knew what set of classes we were planning to compile.  Now mark
9147      those that will be generated locally as not external.  */
9148   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9149     {
9150       tree current;
9151       ctxp = cur_ctxp;
9152       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9153         java_mark_class_local (TREE_TYPE (current));
9154     }
9155
9156   /* Compile the classes.  */
9157   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9158     {
9159       tree current;
9160       reversed_class_list = NULL;
9161
9162       ctxp = cur_ctxp;
9163
9164       /* We write out the classes in reverse order.  This ensures that
9165          inner classes are written before their containing classes,
9166          which is important for parallel builds.  Otherwise, the
9167          class file for the outer class may be found, but the class
9168          file for the inner class may not be present.  In that
9169          situation, the compiler cannot fall back to the original
9170          source, having already read the outer class, so we must
9171          prevent that situation.  */
9172       for (current = ctxp->class_list;
9173            current;
9174            current = TREE_CHAIN (current))
9175         reversed_class_list
9176           = tree_cons (NULL_TREE, current, reversed_class_list);
9177
9178       for (current = reversed_class_list;
9179            current;
9180            current = TREE_CHAIN (current))
9181         {
9182           output_class = current_class = TREE_TYPE (TREE_VALUE (current));
9183           if (flag_emit_class_files)
9184             write_classfile (current_class);
9185           if (flag_emit_xref)
9186             expand_xref (current_class);
9187           else if (! flag_syntax_only)
9188             java_expand_method_bodies (current_class);
9189         }
9190     }
9191 }
9192
9193 void
9194 java_finish_classes (void)
9195 {
9196   static struct parser_ctxt *cur_ctxp = NULL;
9197   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9198     {
9199       tree current;
9200       ctxp = cur_ctxp;
9201       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9202         {
9203           output_class = current_class = TREE_TYPE (current);
9204           finish_class ();
9205         }
9206     }
9207 }
9208
9209 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9210    a tree list node containing RIGHT. Fore coming RIGHTs will be
9211    chained to this hook. LOCATION contains the location of the
9212    separating `.' operator.  */
9213
9214 static tree
9215 make_qualified_primary (tree primary, tree right, int location)
9216 {
9217   tree wfl;
9218
9219   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9220     wfl = build_wfl_wrap (primary, location);
9221   else
9222     {
9223       wfl = primary;
9224       /* If wfl wasn't qualified, we build a first anchor */
9225       if (!EXPR_WFL_QUALIFICATION (wfl))
9226         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9227     }
9228
9229   /* And chain them */
9230   EXPR_WFL_LINECOL (right) = location;
9231   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9232   PRIMARY_P (wfl) =  1;
9233   return wfl;
9234 }
9235
9236 /* Simple merge of two name separated by a `.' */
9237
9238 static tree
9239 merge_qualified_name (tree left, tree right)
9240 {
9241   tree node;
9242   if (!left && !right)
9243     return NULL_TREE;
9244
9245   if (!left)
9246     return right;
9247
9248   if (!right)
9249     return left;
9250
9251   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9252                 IDENTIFIER_LENGTH (left));
9253   obstack_1grow (&temporary_obstack, '.');
9254   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9255                  IDENTIFIER_LENGTH (right));
9256   node =  get_identifier (obstack_base (&temporary_obstack));
9257   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9258   QUALIFIED_P (node) = 1;
9259   return node;
9260 }
9261
9262 /* Merge the two parts of a qualified name into LEFT.  Set the
9263    location information of the resulting node to LOCATION, usually
9264    inherited from the location information of the `.' operator. */
9265
9266 static tree
9267 make_qualified_name (tree left, tree right, int location)
9268 {
9269 #ifdef USE_COMPONENT_REF
9270   tree node = build (COMPONENT_REF, NULL_TREE, left, right);
9271   EXPR_WFL_LINECOL (node) = location;
9272   return node;
9273 #else
9274   tree left_id = EXPR_WFL_NODE (left);
9275   tree right_id = EXPR_WFL_NODE (right);
9276   tree wfl, merge;
9277
9278   merge = merge_qualified_name (left_id, right_id);
9279
9280   /* Left wasn't qualified and is now qualified */
9281   if (!QUALIFIED_P (left_id))
9282     {
9283       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9284       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9285       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9286     }
9287
9288   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9289   EXPR_WFL_LINECOL (wfl) = location;
9290   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9291
9292   EXPR_WFL_NODE (left) = merge;
9293   return left;
9294 #endif
9295 }
9296
9297 /* Extract the last identifier component of the qualified in WFL. The
9298    last identifier is removed from the linked list */
9299
9300 static tree
9301 cut_identifier_in_qualified (tree wfl)
9302 {
9303   tree q;
9304   tree previous = NULL_TREE;
9305   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9306     if (!TREE_CHAIN (q))
9307       {
9308         if (!previous)
9309           /* Operating on a non qualified qualified WFL.  */
9310           abort ();
9311
9312         TREE_CHAIN (previous) = NULL_TREE;
9313         return TREE_PURPOSE (q);
9314       }
9315 }
9316
9317 /* Resolve the expression name NAME. Return its decl.  */
9318
9319 static tree
9320 resolve_expression_name (tree id, tree *orig)
9321 {
9322   tree name = EXPR_WFL_NODE (id);
9323   tree decl;
9324
9325   /* 6.5.5.1: Simple expression names */
9326   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9327     {
9328       /* 15.13.1: NAME can appear within the scope of a local variable
9329          declaration */
9330       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9331         return decl;
9332
9333       /* 15.13.1: NAME can appear within a class declaration */
9334       else
9335         {
9336           decl = lookup_field_wrapper (current_class, name);
9337           if (decl)
9338             {
9339               tree access = NULL_TREE;
9340               int fs = FIELD_STATIC (decl);
9341
9342               /* If we're accessing an outer scope local alias, make
9343                  sure we change the name of the field we're going to
9344                  build access to. */
9345               if (FIELD_LOCAL_ALIAS_USED (decl))
9346                 name = DECL_NAME (decl);
9347
9348               check_deprecation (id, decl);
9349
9350               /* Instance variable (8.3.1.1) can't appear within
9351                  static method, static initializer or initializer for
9352                  a static variable. */
9353               if (!fs && METHOD_STATIC (current_function_decl))
9354                 {
9355                   static_ref_err (id, name, current_class);
9356                   return error_mark_node;
9357                 }
9358               /* Instance variables can't appear as an argument of
9359                  an explicit constructor invocation */
9360               if (!fs && ctxp->explicit_constructor_p
9361                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9362                 {
9363                   parse_error_context
9364                     (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9365                   return error_mark_node;
9366                 }
9367
9368               /* If we're processing an inner class and we're trying
9369                  to access a field belonging to an outer class, build
9370                  the access to the field */
9371               if (!fs && outer_field_access_p (current_class, decl))
9372                 {
9373                   if (CLASS_STATIC (TYPE_NAME (current_class)))
9374                     {
9375                       static_ref_err (id, DECL_NAME (decl), current_class);
9376                       return error_mark_node;
9377                     }
9378                   access = build_outer_field_access (id, decl);
9379                   if (orig)
9380                     *orig = access;
9381                   return access;
9382                 }
9383
9384               /* Otherwise build what it takes to access the field */
9385               access = build_field_ref ((fs ? NULL_TREE : current_this),
9386                                         DECL_CONTEXT (decl), name);
9387               if (fs)
9388                 access = maybe_build_class_init_for_field (decl, access);
9389               /* We may be asked to save the real field access node */
9390               if (orig)
9391                 *orig = access;
9392               /* Last check: can we access the field? */
9393               if (not_accessible_p (current_class, decl, NULL_TREE, 0))
9394                 {
9395                   not_accessible_field_error (id, decl);
9396                   return error_mark_node;
9397                 }
9398               /* And we return what we got */
9399               return access;
9400             }
9401           /* Fall down to error report on undefined variable */
9402         }
9403     }
9404   /* 6.5.5.2 Qualified Expression Names */
9405   else
9406     {
9407       if (orig)
9408         *orig = NULL_TREE;
9409       qualify_ambiguous_name (id);
9410       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9411       /* 15.10.2: Accessing Superclass Members using super */
9412       return resolve_field_access (id, orig, NULL);
9413     }
9414
9415   /* We've got an error here */
9416   if (INNER_CLASS_TYPE_P (current_class))
9417     parse_error_context (id,
9418                          "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9419                          IDENTIFIER_POINTER (name),
9420                          IDENTIFIER_POINTER (DECL_NAME
9421                                              (TYPE_NAME (current_class))));
9422   else
9423     parse_error_context (id, "Undefined variable `%s'",
9424                          IDENTIFIER_POINTER (name));
9425
9426   return error_mark_node;
9427 }
9428
9429 static void
9430 static_ref_err (tree wfl, tree field_id, tree class_type)
9431 {
9432   parse_error_context
9433     (wfl,
9434      "Can't make a static reference to nonstatic variable `%s' in class `%s'",
9435      IDENTIFIER_POINTER (field_id),
9436      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9437 }
9438
9439 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9440    We return something suitable to generate the field access. We also
9441    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9442    recipient's address can be null. */
9443
9444 static tree
9445 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9446 {
9447   int is_static = 0;
9448   tree field_ref;
9449   tree decl, where_found, type_found;
9450
9451   if (resolve_qualified_expression_name (qual_wfl, &decl,
9452                                          &where_found, &type_found))
9453     return error_mark_node;
9454
9455   /* Resolve the LENGTH field of an array here */
9456   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9457       && type_found && TYPE_ARRAY_P (type_found)
9458       && ! flag_emit_class_files && ! flag_emit_xref)
9459     {
9460       tree length = build_java_array_length_access (where_found);
9461       field_ref = length;
9462
9463       /* In case we're dealing with a static array, we need to
9464          initialize its class before the array length can be fetched.
9465          It's also a good time to create a DECL_RTL for the field if
9466          none already exists, otherwise if the field was declared in a
9467          class found in an external file and hasn't been (and won't
9468          be) accessed for its value, none will be created. */
9469       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9470         {
9471           build_static_field_ref (where_found);
9472           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9473         }
9474     }
9475   /* We might have been trying to resolve field.method(). In which
9476      case, the resolution is over and decl is the answer */
9477   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9478     field_ref = decl;
9479   else if (JDECL_P (decl))
9480     {
9481       if (!type_found)
9482         type_found = DECL_CONTEXT (decl);
9483       is_static = FIELD_STATIC (decl);
9484       field_ref = build_field_ref ((is_static && !flag_emit_xref?
9485                                     NULL_TREE : where_found),
9486                                    type_found, DECL_NAME (decl));
9487       if (field_ref == error_mark_node)
9488         return error_mark_node;
9489       if (is_static)
9490         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9491
9492       /* If we're looking at a static field, we may need to generate a
9493          class initialization for it.  This can happen when the access
9494          looks like `field.ref', where `field' is a static field in an
9495          interface we implement.  */
9496       if (!flag_emit_class_files
9497           && !flag_emit_xref
9498           && TREE_CODE (where_found) == VAR_DECL
9499           && FIELD_STATIC (where_found))
9500         {
9501           build_static_field_ref (where_found);
9502           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9503         }
9504     }
9505   else
9506     field_ref = decl;
9507
9508   if (field_decl)
9509     *field_decl = decl;
9510   if (field_type)
9511     *field_type = (QUAL_DECL_TYPE (decl) ?
9512                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9513   return field_ref;
9514 }
9515
9516 /* If NODE is an access to f static field, strip out the class
9517    initialization part and return the field decl, otherwise, return
9518    NODE. */
9519
9520 static tree
9521 strip_out_static_field_access_decl (tree node)
9522 {
9523   if (TREE_CODE (node) == COMPOUND_EXPR)
9524     {
9525       tree op1 = TREE_OPERAND (node, 1);
9526       if (TREE_CODE (op1) == COMPOUND_EXPR)
9527          {
9528            tree call = TREE_OPERAND (op1, 0);
9529            if (TREE_CODE (call) == CALL_EXPR
9530                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9531                && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9532                == soft_initclass_node)
9533              return TREE_OPERAND (op1, 1);
9534          }
9535       else if (JDECL_P (op1))
9536         return op1;
9537     }
9538   return node;
9539 }
9540
9541 /* 6.5.5.2: Qualified Expression Names */
9542
9543 static int
9544 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9545                                    tree *where_found, tree *type_found)
9546 {
9547   int from_type = 0;            /* Field search initiated from a type */
9548   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9549   int previous_call_static = 0;
9550   int is_static;
9551   tree decl = NULL_TREE, type = NULL_TREE, q;
9552   /* For certain for of inner class instantiation */
9553   tree saved_current, saved_this;
9554 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9555   { current_class = saved_current; current_this = saved_this;}
9556
9557   *type_found = *where_found = NULL_TREE;
9558
9559   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9560     {
9561       tree qual_wfl = QUAL_WFL (q);
9562       tree ret_decl;            /* for EH checking */
9563       int location;             /* for EH checking */
9564
9565       /* 15.10.1 Field Access Using a Primary */
9566       switch (TREE_CODE (qual_wfl))
9567         {
9568         case CALL_EXPR:
9569         case NEW_CLASS_EXPR:
9570           /* If the access to the function call is a non static field,
9571              build the code to access it. */
9572           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9573             {
9574               decl = maybe_access_field (decl, *where_found,
9575                                          DECL_CONTEXT (decl));
9576               if (decl == error_mark_node)
9577                 return 1;
9578             }
9579
9580           /* And code for the function call */
9581           if (complete_function_arguments (qual_wfl))
9582             return 1;
9583
9584           /* We might have to setup a new current class and a new this
9585              for the search of an inner class, relative to the type of
9586              a expression resolved as `decl'. The current values are
9587              saved and restored shortly after */
9588           saved_current = current_class;
9589           saved_this = current_this;
9590           if (decl
9591               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9592                   || from_qualified_this))
9593             {
9594               /* If we still have `from_qualified_this', we have the form
9595                  <T>.this.f() and we need to build <T>.this */
9596               if (from_qualified_this)
9597                 {
9598                   decl = build_access_to_thisn (current_class, type, 0);
9599                   decl = java_complete_tree (decl);
9600                   type = TREE_TYPE (TREE_TYPE (decl));
9601                 }
9602               current_class = type;
9603               current_this = decl;
9604               from_qualified_this = 0;
9605             }
9606
9607           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9608             CALL_USING_SUPER (qual_wfl) = 1;
9609           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9610                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9611           *where_found = patch_method_invocation (qual_wfl, decl, type,
9612                                                   from_super,
9613                                                   &is_static, &ret_decl);
9614           from_super = 0;
9615           if (*where_found == error_mark_node)
9616             {
9617               RESTORE_THIS_AND_CURRENT_CLASS;
9618               return 1;
9619             }
9620           *type_found = type = QUAL_DECL_TYPE (*where_found);
9621
9622           *where_found = force_evaluation_order (*where_found);
9623
9624           /* If we're creating an inner class instance, check for that
9625              an enclosing instance is in scope */
9626           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9627               && INNER_ENCLOSING_SCOPE_CHECK (type))
9628             {
9629               parse_error_context
9630                 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
9631                  lang_printable_name (type, 0),
9632                  (!current_this ? "" :
9633                   "; an explicit one must be provided when creating this inner class"));
9634               RESTORE_THIS_AND_CURRENT_CLASS;
9635               return 1;
9636             }
9637
9638           /* In case we had to change then to resolve a inner class
9639              instantiation using a primary qualified by a `new' */
9640           RESTORE_THIS_AND_CURRENT_CLASS;
9641
9642           if (location)
9643             {
9644               tree arguments = NULL_TREE;
9645               if (TREE_CODE (qual_wfl) == CALL_EXPR
9646                   && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9647                 arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9648               check_thrown_exceptions (location, ret_decl, arguments);
9649             }
9650
9651           /* If the previous call was static and this one is too,
9652              build a compound expression to hold the two (because in
9653              that case, previous function calls aren't transported as
9654              forcoming function's argument. */
9655           if (previous_call_static && is_static)
9656             {
9657               decl = build (COMPOUND_EXPR, TREE_TYPE (*where_found),
9658                             decl, *where_found);
9659               TREE_SIDE_EFFECTS (decl) = 1;
9660             }
9661           else
9662             {
9663               previous_call_static = is_static;
9664               decl = *where_found;
9665             }
9666           from_type = 0;
9667           continue;
9668
9669         case NEW_ARRAY_EXPR:
9670         case NEW_ANONYMOUS_ARRAY_EXPR:
9671           *where_found = decl = java_complete_tree (qual_wfl);
9672           if (decl == error_mark_node)
9673             return 1;
9674           *type_found = type = QUAL_DECL_TYPE (decl);
9675           continue;
9676
9677         case CONVERT_EXPR:
9678           *where_found = decl = java_complete_tree (qual_wfl);
9679           if (decl == error_mark_node)
9680             return 1;
9681           *type_found = type = QUAL_DECL_TYPE (decl);
9682           from_cast = 1;
9683           continue;
9684
9685         case CONDITIONAL_EXPR:
9686         case STRING_CST:
9687         case MODIFY_EXPR:
9688           *where_found = decl = java_complete_tree (qual_wfl);
9689           if (decl == error_mark_node)
9690             return 1;
9691           *type_found = type = QUAL_DECL_TYPE (decl);
9692           continue;
9693
9694         case ARRAY_REF:
9695           /* If the access to the function call is a non static field,
9696              build the code to access it. */
9697           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9698             {
9699               decl = maybe_access_field (decl, *where_found, type);
9700               if (decl == error_mark_node)
9701                 return 1;
9702             }
9703           /* And code for the array reference expression */
9704           decl = java_complete_tree (qual_wfl);
9705           if (decl == error_mark_node)
9706             return 1;
9707           type = QUAL_DECL_TYPE (decl);
9708           continue;
9709
9710         case PLUS_EXPR:
9711           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9712             return 1;
9713           if ((type = patch_string (decl)))
9714             decl = type;
9715           *where_found = QUAL_RESOLUTION (q) = decl;
9716           *type_found = type = TREE_TYPE (decl);
9717           break;
9718
9719         case CLASS_LITERAL:
9720           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9721             return 1;
9722           *where_found = QUAL_RESOLUTION (q) = decl;
9723           *type_found = type = TREE_TYPE (decl);
9724           break;
9725
9726         default:
9727           /* Fix for -Wall Just go to the next statement. Don't
9728              continue */
9729           break;
9730         }
9731
9732       /* If we fall here, we weren't processing a (static) function call. */
9733       previous_call_static = 0;
9734
9735       /* It can be the keyword THIS */
9736       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9737           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9738         {
9739           if (!current_this)
9740             {
9741               parse_error_context
9742                 (wfl, "Keyword `this' used outside allowed context");
9743               return 1;
9744             }
9745           if (ctxp->explicit_constructor_p
9746               && type == current_class)
9747             {
9748               parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9749               return 1;
9750             }
9751           /* We have to generate code for intermediate access */
9752           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9753             {
9754               *where_found = decl = current_this;
9755               *type_found = type = QUAL_DECL_TYPE (decl);
9756             }
9757           /* We're trying to access the this from somewhere else. Make sure
9758              it's allowed before doing so. */
9759           else
9760             {
9761               if (!enclosing_context_p (type, current_class))
9762                 {
9763                   char *p  = xstrdup (lang_printable_name (type, 0));
9764                   parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9765                                        p, p,
9766                                        lang_printable_name (current_class, 0));
9767                   free (p);
9768                   return 1;
9769                 }
9770               from_qualified_this = 1;
9771               /* If there's nothing else after that, we need to
9772                  produce something now, otherwise, the section of the
9773                  code that needs to produce <T>.this will generate
9774                  what is necessary. */
9775               if (!TREE_CHAIN (q))
9776                 {
9777                   decl = build_access_to_thisn (current_class, type, 0);
9778                   *where_found = decl = java_complete_tree (decl);
9779                   *type_found = type = TREE_TYPE (decl);
9780                 }
9781             }
9782
9783           from_type = 0;
9784           continue;
9785         }
9786
9787       /* 15.10.2 Accessing Superclass Members using SUPER */
9788       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9789           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9790         {
9791           tree node;
9792           /* Check on the restricted use of SUPER */
9793           if (METHOD_STATIC (current_function_decl)
9794               || current_class == object_type_node)
9795             {
9796               parse_error_context
9797                 (wfl, "Keyword `super' used outside allowed context");
9798               return 1;
9799             }
9800           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9801           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9802                              CLASSTYPE_SUPER (current_class),
9803                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9804           *where_found = decl = java_complete_tree (node);
9805           if (decl == error_mark_node)
9806             return 1;
9807           *type_found = type = QUAL_DECL_TYPE (decl);
9808           from_super = from_type = 1;
9809           continue;
9810         }
9811
9812       /* 15.13.1: Can't search for field name in packages, so we
9813          assume a variable/class name was meant. */
9814       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9815         {
9816           tree name;
9817           if ((decl = resolve_package (wfl, &q, &name)))
9818             {
9819               tree list;
9820               *where_found = decl;
9821
9822               /* We want to be absolutely sure that the class is laid
9823                  out. We're going to search something inside it. */
9824               *type_found = type = TREE_TYPE (decl);
9825               layout_class (type);
9826               from_type = 1;
9827
9828               /* Fix them all the way down, if any are left. */
9829               if (q)
9830                 {
9831                   list = TREE_CHAIN (q);
9832                   while (list)
9833                     {
9834                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9835                       list = TREE_CHAIN (list);
9836                     }
9837                 }
9838             }
9839           else
9840             {
9841               if (from_super || from_cast)
9842                 parse_error_context
9843                   ((from_cast ? qual_wfl : wfl),
9844                    "No variable `%s' defined in class `%s'",
9845                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9846                    lang_printable_name (type, 0));
9847               else
9848                 parse_error_context
9849                   (qual_wfl, "Undefined variable or class name: `%s'",
9850                    IDENTIFIER_POINTER (name));
9851               return 1;
9852             }
9853         }
9854
9855       /* We have a type name. It's been already resolved when the
9856          expression was qualified. */
9857       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9858         {
9859           decl = QUAL_RESOLUTION (q);
9860
9861           /* Sneak preview. If next we see a `new', we're facing a
9862              qualification with resulted in a type being selected
9863              instead of a field.  Report the error */
9864           if(TREE_CHAIN (q)
9865              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9866             {
9867               parse_error_context (qual_wfl, "Undefined variable `%s'",
9868                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9869               return 1;
9870             }
9871
9872           if (not_accessible_p (TREE_TYPE (decl), decl, type, 0))
9873             {
9874               parse_error_context
9875                 (qual_wfl, "Can't access %s class '%s' from '%s'",
9876                  java_accstring_lookup (get_access_flags_from_decl (decl)),
9877                  IDENTIFIER_POINTER (DECL_NAME (decl)),
9878                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
9879               return 1;
9880             }
9881           check_deprecation (qual_wfl, decl);
9882
9883           type = TREE_TYPE (decl);
9884           from_type = 1;
9885         }
9886       /* We resolve an expression name */
9887       else
9888         {
9889           tree field_decl = NULL_TREE;
9890
9891           /* If there exists an early resolution, use it. That occurs
9892              only once and we know that there are more things to
9893              come. Don't do that when processing something after SUPER
9894              (we need more thing to be put in place below */
9895           if (!from_super && QUAL_RESOLUTION (q))
9896             {
9897               decl = QUAL_RESOLUTION (q);
9898               if (!type)
9899                 {
9900                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9901                     {
9902                       if (current_this)
9903                         *where_found = current_this;
9904                       else
9905                         {
9906                           static_ref_err (qual_wfl, DECL_NAME (decl),
9907                                           current_class);
9908                           return 1;
9909                         }
9910                       if (outer_field_access_p (current_class, decl))
9911                         decl = build_outer_field_access (qual_wfl, decl);
9912                     }
9913                   else
9914                     {
9915                       *where_found = TREE_TYPE (decl);
9916                       if (TREE_CODE (*where_found) == POINTER_TYPE)
9917                         *where_found = TREE_TYPE (*where_found);
9918                     }
9919                 }
9920             }
9921
9922           /* Report and error if we're using a numerical literal as a
9923              qualifier. It can only be an INTEGER_CST. */
9924           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9925             {
9926               parse_error_context
9927                 (wfl, "Can't use type `%s' as a qualifier",
9928                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
9929               return 1;
9930             }
9931
9932           /* We have to search for a field, knowing the type of its
9933              container. The flag FROM_TYPE indicates that we resolved
9934              the last member of the expression as a type name, which
9935              means that for the resolution of this field, we'll look
9936              for other errors than if it was resolved as a member of
9937              an other field. */
9938           else
9939             {
9940               int is_static;
9941               tree field_decl_type; /* For layout */
9942
9943               if (!from_type && !JREFERENCE_TYPE_P (type))
9944                 {
9945                   parse_error_context
9946                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9947                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9948                      lang_printable_name (type, 0),
9949                      IDENTIFIER_POINTER (DECL_NAME (decl)));
9950                   return 1;
9951                 }
9952
9953               field_decl = lookup_field_wrapper (type,
9954                                                  EXPR_WFL_NODE (qual_wfl));
9955
9956               /* Maybe what we're trying to access to is an inner
9957                  class, only if decl is a TYPE_DECL. */
9958               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9959                 {
9960                   tree ptr, inner_decl;
9961
9962                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9963                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9964                   if (inner_decl)
9965                     {
9966                       check_inner_class_access (inner_decl, decl, qual_wfl);
9967                       type = TREE_TYPE (inner_decl);
9968                       decl = inner_decl;
9969                       from_type = 1;
9970                       continue;
9971                     }
9972                 }
9973
9974               if (field_decl == NULL_TREE)
9975                 {
9976                   parse_error_context
9977                     (qual_wfl, "No variable `%s' defined in type `%s'",
9978                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9979                      GET_TYPE_NAME (type));
9980                   return 1;
9981                 }
9982               if (field_decl == error_mark_node)
9983                 return 1;
9984
9985               /* Layout the type of field_decl, since we may need
9986                  it. Don't do primitive types or loaded classes. The
9987                  situation of non primitive arrays may not handled
9988                  properly here. FIXME */
9989               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9990                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9991               else
9992                 field_decl_type = TREE_TYPE (field_decl);
9993               if (!JPRIMITIVE_TYPE_P (field_decl_type)
9994                   && !CLASS_LOADED_P (field_decl_type)
9995                   && !TYPE_ARRAY_P (field_decl_type))
9996                 resolve_and_layout (field_decl_type, NULL_TREE);
9997
9998               /* Check on accessibility here */
9999               if (not_accessible_p (current_class, field_decl,
10000                                     DECL_CONTEXT (field_decl), from_super))
10001                 return not_accessible_field_error (qual_wfl,field_decl);
10002               check_deprecation (qual_wfl, field_decl);
10003
10004               /* There are things to check when fields are accessed
10005                  from type. There are no restrictions on a static
10006                  declaration of the field when it is accessed from an
10007                  interface */
10008               is_static = FIELD_STATIC (field_decl);
10009               if (!from_super && from_type
10010                   && !TYPE_INTERFACE_P (type)
10011                   && !is_static
10012                   && (current_function_decl
10013                       && METHOD_STATIC (current_function_decl)))
10014                 {
10015                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
10016                   return 1;
10017                 }
10018               from_cast = from_super = 0;
10019
10020               /* It's an access from a type but it isn't static, we
10021                  make it relative to `this'. */
10022               if (!is_static && from_type)
10023                 decl = current_this;
10024
10025               /* If we need to generate something to get a proper
10026                  handle on what this field is accessed from, do it
10027                  now. */
10028               if (!is_static)
10029                 {
10030                   decl = maybe_access_field (decl, *where_found, *type_found);
10031                   if (decl == error_mark_node)
10032                     return 1;
10033                 }
10034
10035               /* We want to keep the location were found it, and the type
10036                  we found. */
10037               *where_found = decl;
10038               *type_found = type;
10039
10040               /* Generate the correct expression for field access from
10041                  qualified this */
10042               if (from_qualified_this)
10043                 {
10044                   field_decl = build_outer_field_access (qual_wfl, field_decl);
10045                   from_qualified_this = 0;
10046                 }
10047
10048               /* This is the decl found and eventually the next one to
10049                  search from */
10050               decl = field_decl;
10051             }
10052           from_type = 0;
10053           type = QUAL_DECL_TYPE (decl);
10054
10055           /* Sneak preview. If decl is qualified by a `new', report
10056              the error here to be accurate on the peculiar construct */
10057           if (TREE_CHAIN (q)
10058               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10059               && !JREFERENCE_TYPE_P (type))
10060             {
10061               parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
10062                                    lang_printable_name (type, 0));
10063               return 1;
10064             }
10065         }
10066       /* `q' might have changed due to a after package resolution
10067          re-qualification */
10068       if (!q)
10069         break;
10070     }
10071   *found_decl = decl;
10072   return 0;
10073 }
10074
10075 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10076    can't be accessed from REFERENCE (a record type). If MEMBER
10077    features a protected access, we then use WHERE which, if non null,
10078    holds the type of MEMBER's access that is checked against
10079    6.6.2.1. This function should be used when decl is a field or a
10080    method.  */
10081
10082 static int
10083 not_accessible_p (tree reference, tree member, tree where, int from_super)
10084 {
10085   int access_flag = get_access_flags_from_decl (member);
10086
10087   /* Inner classes are processed by check_inner_class_access */
10088   if (INNER_CLASS_TYPE_P (reference))
10089     return 0;
10090
10091   /* Access always granted for members declared public */
10092   if (access_flag & ACC_PUBLIC)
10093     return 0;
10094
10095   /* Check access on protected members */
10096   if (access_flag & ACC_PROTECTED)
10097     {
10098       /* Access granted if it occurs from within the package
10099          containing the class in which the protected member is
10100          declared */
10101       if (class_in_current_package (DECL_CONTEXT (member)))
10102         return 0;
10103
10104       /* If accessed with the form `super.member', then access is granted */
10105       if (from_super)
10106         return 0;
10107
10108       /* If where is active, access was made through a
10109          qualifier. Access is granted if the type of the qualifier is
10110          or is a sublass of the type the access made from (6.6.2.1.)  */
10111       if (where && !inherits_from_p (reference, where))
10112         return 1;
10113
10114       /* Otherwise, access is granted if occurring from the class where
10115          member is declared or a subclass of it. Find the right
10116          context to perform the check */
10117       if (PURE_INNER_CLASS_TYPE_P (reference))
10118         {
10119           while (INNER_CLASS_TYPE_P (reference))
10120             {
10121               if (inherits_from_p (reference, DECL_CONTEXT (member)))
10122                 return 0;
10123               reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10124             }
10125         }
10126       if (inherits_from_p (reference, DECL_CONTEXT (member)))
10127         return 0;
10128       return 1;
10129     }
10130
10131   /* Check access on private members. Access is granted only if it
10132      occurs from within the class in which it is declared -- that does
10133      it for innerclasses too. */
10134   if (access_flag & ACC_PRIVATE)
10135     {
10136       if (reference == DECL_CONTEXT (member))
10137         return 0;
10138       if (enclosing_context_p (reference, DECL_CONTEXT (member)))
10139         return 0;
10140       return 1;
10141     }
10142
10143   /* Default access are permitted only when occurring within the
10144      package in which the type (REFERENCE) is declared. In other words,
10145      REFERENCE is defined in the current package */
10146   if (ctxp->package)
10147     return !class_in_current_package (reference);
10148
10149   /* Otherwise, access is granted */
10150   return 0;
10151 }
10152
10153 /* Test deprecated decl access.  */
10154 static void
10155 check_deprecation (tree wfl, tree decl)
10156 {
10157   const char *file;
10158   tree elt;
10159
10160   if (! flag_deprecated)
10161     return;
10162
10163   /* We want to look at the element type of arrays here, so we strip
10164      all surrounding array types.  */
10165   if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10166     {
10167       elt = TREE_TYPE (decl);
10168       while (TYPE_ARRAY_P (elt))
10169         elt = TYPE_ARRAY_ELEMENT (elt);
10170       /* We'll end up with a pointer type, so we use TREE_TYPE to go
10171          to the record.  */
10172       decl = TYPE_NAME (TREE_TYPE (elt));
10173     }
10174   file = DECL_SOURCE_FILE (decl);
10175
10176   /* Complain if the field is deprecated and the file it was defined
10177      in isn't compiled at the same time the file which contains its
10178      use is */
10179   if (DECL_DEPRECATED (decl)
10180       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10181     {
10182       const char *the;
10183       switch (TREE_CODE (decl))
10184         {
10185         case FUNCTION_DECL:
10186           the = "method";
10187           break;
10188         case FIELD_DECL:
10189         case VAR_DECL:
10190           the = "field";
10191           break;
10192         case TYPE_DECL:
10193           parse_warning_context (wfl, "The class `%s' has been deprecated",
10194                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10195           return;
10196         default:
10197           abort ();
10198         }
10199       /* Don't issue a message if the context as been deprecated as a
10200          whole. */
10201       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10202         parse_warning_context
10203           (wfl, "The %s `%s' in class `%s' has been deprecated",
10204            the, lang_printable_name (decl, 0),
10205            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10206     }
10207 }
10208
10209 /* Returns 1 if class was declared in the current package, 0 otherwise */
10210
10211 static GTY(()) tree cicp_cache;
10212 static int
10213 class_in_current_package (tree class)
10214 {
10215   int qualified_flag;
10216   tree left;
10217
10218   if (cicp_cache == class)
10219     return 1;
10220
10221   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10222
10223   /* If the current package is empty and the name of CLASS is
10224      qualified, class isn't in the current package.  If there is a
10225      current package and the name of the CLASS is not qualified, class
10226      isn't in the current package */
10227   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10228     return 0;
10229
10230   /* If there is not package and the name of CLASS isn't qualified,
10231      they belong to the same unnamed package */
10232   if (!ctxp->package && !qualified_flag)
10233     return 1;
10234
10235   /* Compare the left part of the name of CLASS with the package name */
10236   breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10237   if (ctxp->package == left)
10238     {
10239       cicp_cache = class;
10240       return 1;
10241     }
10242   return 0;
10243 }
10244
10245 /* This function may generate code to access DECL from WHERE. This is
10246    done only if certain conditions meet.  */
10247
10248 static tree
10249 maybe_access_field (tree decl, tree where, tree type)
10250 {
10251   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10252       && !FIELD_STATIC (decl))
10253     decl = build_field_ref (where ? where : current_this,
10254                             (type ? type : DECL_CONTEXT (decl)),
10255                             DECL_NAME (decl));
10256   return decl;
10257 }
10258
10259 /* Build a method invocation, by patching PATCH. If non NULL
10260    and according to the situation, PRIMARY and WHERE may be
10261    used. IS_STATIC is set to 1 if the invoked function is static. */
10262
10263 static tree
10264 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10265                          int *is_static, tree *ret_decl)
10266 {
10267   tree wfl = TREE_OPERAND (patch, 0);
10268   tree args = TREE_OPERAND (patch, 1);
10269   tree name = EXPR_WFL_NODE (wfl);
10270   tree list;
10271   int is_static_flag = 0;
10272   int is_super_init = 0;
10273   tree this_arg = NULL_TREE;
10274   int is_array_clone_call = 0;
10275
10276   /* Should be overridden if everything goes well. Otherwise, if
10277      something fails, it should keep this value. It stop the
10278      evaluation of a bogus assignment. See java_complete_tree,
10279      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10280      evaluating an assignment */
10281   TREE_TYPE (patch) = error_mark_node;
10282
10283   /* Since lookup functions are messing with line numbers, save the
10284      context now.  */
10285   java_parser_context_save_global ();
10286
10287   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10288
10289   /* Resolution of qualified name, excluding constructors */
10290   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10291     {
10292       tree identifier, identifier_wfl, type, resolved;
10293       /* Extract the last IDENTIFIER of the qualified
10294          expression. This is a wfl and we will use it's location
10295          data during error report. */
10296       identifier_wfl = cut_identifier_in_qualified (wfl);
10297       identifier = EXPR_WFL_NODE (identifier_wfl);
10298
10299       /* Given the context, IDENTIFIER is syntactically qualified
10300          as a MethodName. We need to qualify what's before */
10301       qualify_ambiguous_name (wfl);
10302       resolved = resolve_field_access (wfl, NULL, NULL);
10303
10304       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10305          && FIELD_FINAL (resolved)
10306          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10307          && !flag_emit_class_files && !flag_emit_xref)
10308        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10309
10310       if (resolved == error_mark_node)
10311         PATCH_METHOD_RETURN_ERROR ();
10312
10313       type = GET_SKIP_TYPE (resolved);
10314       resolve_and_layout (type, NULL_TREE);
10315
10316       if (JPRIMITIVE_TYPE_P (type))
10317         {
10318           parse_error_context
10319             (identifier_wfl,
10320              "Can't invoke a method on primitive type `%s'",
10321              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10322           PATCH_METHOD_RETURN_ERROR ();
10323         }
10324
10325       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10326       args = nreverse (args);
10327
10328       /* We're resolving a call from a type */
10329       if (TREE_CODE (resolved) == TYPE_DECL)
10330         {
10331           if (CLASS_INTERFACE (resolved))
10332             {
10333               parse_error_context
10334                 (identifier_wfl,
10335                 "Can't make static reference to method `%s' in interface `%s'",
10336                  IDENTIFIER_POINTER (identifier),
10337                  IDENTIFIER_POINTER (name));
10338               PATCH_METHOD_RETURN_ERROR ();
10339             }
10340           if (list && !METHOD_STATIC (list))
10341             {
10342               char *fct_name = xstrdup (lang_printable_name (list, 0));
10343               parse_error_context
10344                 (identifier_wfl,
10345                  "Can't make static reference to method `%s %s' in class `%s'",
10346                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10347                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10348               free (fct_name);
10349               PATCH_METHOD_RETURN_ERROR ();
10350             }
10351         }
10352       else
10353         this_arg = primary = resolved;
10354
10355       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10356         is_array_clone_call = 1;
10357
10358       /* IDENTIFIER_WFL will be used to report any problem further */
10359       wfl = identifier_wfl;
10360     }
10361   /* Resolution of simple names, names generated after a primary: or
10362      constructors */
10363   else
10364     {
10365       tree class_to_search = NULL_TREE;
10366       int lc;                   /* Looking for Constructor */
10367
10368       /* We search constructor in their target class */
10369       if (CALL_CONSTRUCTOR_P (patch))
10370         {
10371           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10372             class_to_search = EXPR_WFL_NODE (wfl);
10373           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10374                    this_identifier_node)
10375             class_to_search = NULL_TREE;
10376           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10377                    super_identifier_node)
10378             {
10379               is_super_init = 1;
10380               if (CLASSTYPE_SUPER (current_class))
10381                 class_to_search =
10382                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10383               else
10384                 {
10385                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10386                   PATCH_METHOD_RETURN_ERROR ();
10387                 }
10388             }
10389
10390           /* Class to search is NULL if we're searching the current one */
10391           if (class_to_search)
10392             {
10393               class_to_search = resolve_and_layout (class_to_search, wfl);
10394
10395               if (!class_to_search)
10396                 {
10397                   parse_error_context
10398                     (wfl, "Class `%s' not found in type declaration",
10399                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10400                   PATCH_METHOD_RETURN_ERROR ();
10401                 }
10402
10403               /* Can't instantiate an abstract class, but we can
10404                  invoke it's constructor. It's use within the `new'
10405                  context is denied here. */
10406               if (CLASS_ABSTRACT (class_to_search)
10407                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10408                 {
10409                   parse_error_context
10410                     (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10411                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10412                   PATCH_METHOD_RETURN_ERROR ();
10413                 }
10414
10415               class_to_search = TREE_TYPE (class_to_search);
10416             }
10417           else
10418             class_to_search = current_class;
10419           lc = 1;
10420         }
10421       /* This is a regular search in the local class, unless an
10422          alternate class is specified. */
10423       else
10424         {
10425           if (where != NULL_TREE)
10426             class_to_search = where;
10427           else if (QUALIFIED_P (name))
10428             class_to_search = current_class;
10429           else
10430             {
10431               class_to_search = current_class;
10432
10433               for (;;)
10434                 {
10435                   if (has_method (class_to_search, name))
10436                     break;
10437                   if (! INNER_CLASS_TYPE_P (class_to_search))
10438                     {
10439                       parse_error_context (wfl,
10440                                            "No method named `%s' in scope",
10441                                            IDENTIFIER_POINTER (name));
10442                       PATCH_METHOD_RETURN_ERROR ();
10443                     }
10444                   class_to_search
10445                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10446                 }
10447             }
10448           lc = 0;
10449         }
10450
10451       /* NAME is a simple identifier or comes from a primary. Search
10452          in the class whose declaration contain the method being
10453          invoked. */
10454       resolve_and_layout (class_to_search, NULL_TREE);
10455
10456       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10457       /* Don't continue if no method were found, as the next statement
10458          can't be executed then. */
10459       if (!list)
10460         PATCH_METHOD_RETURN_ERROR ();
10461
10462       if (TYPE_ARRAY_P (class_to_search)
10463           && DECL_NAME (list) == get_identifier ("clone"))
10464         is_array_clone_call = 1;
10465
10466       /* Check for static reference if non static methods */
10467       if (check_for_static_method_reference (wfl, patch, list,
10468                                              class_to_search, primary))
10469         PATCH_METHOD_RETURN_ERROR ();
10470
10471       /* Check for inner classes creation from illegal contexts */
10472       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10473                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10474           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10475           && !DECL_INIT_P (current_function_decl))
10476         {
10477           parse_error_context
10478             (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10479              lang_printable_name (class_to_search, 0),
10480              (!current_this ? "" :
10481               "; an explicit one must be provided when creating this inner class"));
10482           PATCH_METHOD_RETURN_ERROR ();
10483         }
10484
10485       /* Non static methods are called with the current object extra
10486          argument. If patch a `new TYPE()', the argument is the value
10487          returned by the object allocator. If method is resolved as a
10488          primary, use the primary otherwise use the current THIS. */
10489       args = nreverse (args);
10490       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10491         {
10492           this_arg = primary ? primary : current_this;
10493
10494           /* If we're using an access method, things are different.
10495              There are two family of cases:
10496
10497              1) We're not generating bytecodes:
10498
10499              - LIST is non static. It's invocation is transformed from
10500                x(a1,...,an) into this$<n>.x(a1,....an).
10501              - LIST is static. It's invocation is transformed from
10502                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10503
10504              2) We're generating bytecodes:
10505
10506              - LIST is non static. It's invocation is transformed from
10507                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10508              - LIST is static. It's invocation is transformed from
10509                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10510
10511              Of course, this$<n> can be arbitrarily complex, ranging from
10512              this$0 (the immediate outer context) to
10513              access$0(access$0(...(this$0))).
10514
10515              maybe_use_access_method returns a nonzero value if the
10516              this_arg has to be moved into the (then generated) stub
10517              argument list. In the meantime, the selected function
10518              might have be replaced by a generated stub. */
10519           if (!primary &&
10520               maybe_use_access_method (is_super_init, &list, &this_arg))
10521             {
10522               args = tree_cons (NULL_TREE, this_arg, args);
10523               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10524             }
10525         }
10526     }
10527
10528   /* Merge point of all resolution schemes. If we have nothing, this
10529      is an error, already signaled */
10530   if (!list)
10531     PATCH_METHOD_RETURN_ERROR ();
10532
10533   /* Check accessibility, position the is_static flag, build and
10534      return the call */
10535   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10536                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10537                          NULL_TREE), from_super)
10538       /* Calls to clone() on array types are permitted as a special-case. */
10539       && !is_array_clone_call)
10540     {
10541       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10542       const char *const access =
10543         java_accstring_lookup (get_access_flags_from_decl (list));
10544       const char *const klass =
10545         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10546       const char *const refklass =
10547         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10548       const char *const what = (DECL_CONSTRUCTOR_P (list)
10549                                 ? "constructor" : "method");
10550       /* FIXME: WFL yields the wrong message here but I don't know
10551          what else to use.  */
10552       parse_error_context (wfl,
10553                            "Can't access %s %s `%s.%s' from `%s'",
10554                            access, what, klass, fct_name, refklass);
10555       PATCH_METHOD_RETURN_ERROR ();
10556     }
10557
10558   /* Deprecation check: check whether the method being invoked or the
10559      instance-being-created's type are deprecated.  */
10560   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10561     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10562   check_deprecation (wfl, list);
10563
10564   /* If invoking a innerclass constructor, there are hidden parameters
10565      to pass */
10566   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10567       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10568     {
10569       /* And make sure we add the accessed local variables to be saved
10570          in field aliases. */
10571       args = build_alias_initializer_parameter_list
10572         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10573
10574       /* Secretly pass the current_this/primary as a second argument */
10575       if (primary || current_this)
10576         {
10577           tree extra_arg;
10578           tree this_type = (current_this ?
10579                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10580           /* Method's (list) enclosing context */
10581           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10582           /* If we have a primary, use it. */
10583           if (primary)
10584             extra_arg = primary;
10585           /* The current `this' is an inner class but isn't a direct
10586              enclosing context for the inner class we're trying to
10587              create. Build an access to the proper enclosing context
10588              and use it. */
10589           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10590                    && this_type != TREE_TYPE (mec))
10591             {
10592
10593               extra_arg = build_access_to_thisn (current_class,
10594                                                  TREE_TYPE (mec), 0);
10595               extra_arg = java_complete_tree (extra_arg);
10596             }
10597           /* Otherwise, just use the current `this' as an enclosing
10598              context. */
10599           else
10600             extra_arg = current_this;
10601           args = tree_cons (NULL_TREE, extra_arg, args);
10602         }
10603       else
10604         args = tree_cons (NULL_TREE, integer_zero_node, args);
10605     }
10606
10607   /* This handles the situation where a constructor invocation needs
10608      to have an enclosing context passed as a second parameter (the
10609      constructor is one of an inner class). */
10610   if ((is_super_init ||
10611        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10612       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10613     {
10614       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10615       tree extra_arg =
10616         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10617       extra_arg = java_complete_tree (extra_arg);
10618       args = tree_cons (NULL_TREE, extra_arg, args);
10619     }
10620
10621   is_static_flag = METHOD_STATIC (list);
10622   if (! is_static_flag && this_arg != NULL_TREE)
10623     args = tree_cons (NULL_TREE, this_arg, args);
10624
10625   /* In the context of an explicit constructor invocation, we can't
10626      invoke any method relying on `this'. Exceptions are: we're
10627      invoking a static function, primary exists and is not the current
10628      this, we're creating a new object. */
10629   if (ctxp->explicit_constructor_p
10630       && !is_static_flag
10631       && (!primary || primary == current_this)
10632       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10633     {
10634       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10635       PATCH_METHOD_RETURN_ERROR ();
10636     }
10637   java_parser_context_restore_global ();
10638   if (is_static)
10639     *is_static = is_static_flag;
10640   /* Sometimes, we want the decl of the selected method. Such as for
10641      EH checking */
10642   if (ret_decl)
10643     *ret_decl = list;
10644   patch = patch_invoke (patch, list, args);
10645
10646   /* Now is a good time to insert the call to finit$ */
10647   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10648     {
10649       tree finit_parms, finit_call;
10650
10651       /* Prepare to pass hidden parameters to finit$, if any. */
10652       finit_parms = build_alias_initializer_parameter_list
10653         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10654
10655       finit_call =
10656         build_method_invocation (build_wfl_node (finit_identifier_node),
10657                                  finit_parms);
10658
10659       /* Generate the code used to initialize fields declared with an
10660          initialization statement and build a compound statement along
10661          with the super constructor invocation. */
10662       CAN_COMPLETE_NORMALLY (patch) = 1;
10663       patch = build (COMPOUND_EXPR, void_type_node, patch,
10664                      java_complete_tree (finit_call));
10665     }
10666   return patch;
10667 }
10668
10669 /* Check that we're not trying to do a static reference to a method in
10670    non static method. Return 1 if it's the case, 0 otherwise. */
10671
10672 static int
10673 check_for_static_method_reference (tree wfl, tree node, tree method,
10674                                    tree where, tree primary)
10675 {
10676   if (METHOD_STATIC (current_function_decl)
10677       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10678     {
10679       char *fct_name = xstrdup (lang_printable_name (method, 0));
10680       parse_error_context
10681         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10682          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10683          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10684       free (fct_name);
10685       return 1;
10686     }
10687   return 0;
10688 }
10689
10690 /* Fix the invocation of *MDECL if necessary in the case of a
10691    invocation from an inner class. *THIS_ARG might be modified
10692    appropriately and an alternative access to *MDECL might be
10693    returned.  */
10694
10695 static int
10696 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10697 {
10698   tree ctx;
10699   tree md = *mdecl, ta = *this_arg;
10700   int to_return = 0;
10701   int non_static_context = !METHOD_STATIC (md);
10702
10703   if (is_super_init
10704       || DECL_CONTEXT (md) == current_class
10705       || !PURE_INNER_CLASS_TYPE_P (current_class)
10706       || DECL_FINIT_P (md)
10707       || DECL_INSTINIT_P (md))
10708     return 0;
10709
10710   /* If we're calling a method found in an enclosing class, generate
10711      what it takes to retrieve the right this. Don't do that if we're
10712      invoking a static method. Note that if MD's type is unrelated to
10713      CURRENT_CLASS, then the current this can be used. */
10714
10715   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10716     {
10717       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10718       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10719         {
10720           ta = build_current_thisn (current_class);
10721           ta = build_wfl_node (ta);
10722         }
10723       else
10724         {
10725           tree type = ctx;
10726           while (type)
10727             {
10728               maybe_build_thisn_access_method (type);
10729               if (inherits_from_p (type, DECL_CONTEXT (md)))
10730                 {
10731                   ta = build_access_to_thisn (ctx, type, 0);
10732                   break;
10733                 }
10734               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10735                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10736             }
10737         }
10738       ta = java_complete_tree (ta);
10739     }
10740
10741   /* We might have to use an access method to get to MD. We can
10742      break the method access rule as far as we're not generating
10743      bytecode */
10744   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10745     {
10746       md = build_outer_method_access_method (md);
10747       to_return = 1;
10748     }
10749
10750   *mdecl = md;
10751   *this_arg = ta;
10752
10753   /* Returning a nonzero value indicates we were doing a non static
10754      method invocation that is now a static invocation. It will have
10755      callee displace `this' to insert it in the regular argument
10756      list. */
10757   return (non_static_context && to_return);
10758 }
10759
10760 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10761    mode.  */
10762
10763 static tree
10764 patch_invoke (tree patch, tree method, tree args)
10765 {
10766   tree dtable, func;
10767   tree original_call, t, ta;
10768   tree check = NULL_TREE;
10769
10770   /* Last step for args: convert build-in types. If we're dealing with
10771      a new TYPE() type call, the first argument to the constructor
10772      isn't found in the incoming argument list, but delivered by
10773      `new' */
10774   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10775   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10776     t = TREE_CHAIN (t);
10777   for (ta = args; t != end_params_node && ta;
10778        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10779     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10780         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10781       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10782
10783   /* Resolve unresolved returned type issues */
10784   t = TREE_TYPE (TREE_TYPE (method));
10785   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10786     resolve_and_layout (TREE_TYPE (t), NULL);
10787
10788   if (flag_emit_class_files || flag_emit_xref)
10789     func = method;
10790   else
10791     {
10792       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10793         {
10794         case INVOKE_VIRTUAL:
10795           dtable = invoke_build_dtable (0, args);
10796           func = build_invokevirtual (dtable, method);
10797           break;
10798
10799         case INVOKE_NONVIRTUAL:
10800           /* If the object for the method call is null, we throw an
10801              exception.  We don't do this if the object is the current
10802              method's `this'.  In other cases we just rely on an
10803              optimization pass to eliminate redundant checks.  */
10804           if (TREE_VALUE (args) != current_this)
10805             {
10806               /* We use a save_expr here to make sure we only evaluate
10807                  the new `self' expression once.  */
10808               tree save_arg = save_expr (TREE_VALUE (args));
10809               TREE_VALUE (args) = save_arg;
10810               check = java_check_reference (save_arg, 1);
10811             }
10812           /* Fall through.  */
10813
10814         case INVOKE_SUPER:
10815         case INVOKE_STATIC:
10816           {
10817             tree signature = build_java_signature (TREE_TYPE (method));
10818             func = build_known_method_ref (method, TREE_TYPE (method),
10819                                            DECL_CONTEXT (method),
10820                                            signature, args);
10821           }
10822           break;
10823
10824         case INVOKE_INTERFACE:
10825           dtable = invoke_build_dtable (1, args);
10826           func = build_invokeinterface (dtable, method);
10827           break;
10828
10829         default:
10830           abort ();
10831         }
10832
10833       /* Ensure self_type is initialized, (invokestatic). FIXME */
10834       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10835     }
10836
10837   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10838   TREE_OPERAND (patch, 0) = func;
10839   TREE_OPERAND (patch, 1) = args;
10840   patch = check_for_builtin (method, patch);
10841   original_call = patch;
10842
10843   /* We're processing a `new TYPE ()' form. New is called and its
10844      returned value is the first argument to the constructor. We build
10845      a COMPOUND_EXPR and use saved expression so that the overall NEW
10846      expression value is a pointer to a newly created and initialized
10847      class. */
10848   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10849     {
10850       tree class = DECL_CONTEXT (method);
10851       tree c1, saved_new, size, new;
10852       tree alloc_node;
10853
10854       if (flag_emit_class_files || flag_emit_xref)
10855         {
10856           TREE_TYPE (patch) = build_pointer_type (class);
10857           return patch;
10858         }
10859       if (!TYPE_SIZE (class))
10860         safe_layout_class (class);
10861       size = size_in_bytes (class);
10862       alloc_node =
10863         (class_has_finalize_method (class) ? alloc_object_node
10864                                            : alloc_no_finalizer_node);
10865       new = build (CALL_EXPR, promote_type (class),
10866                    build_address_of (alloc_node),
10867                    tree_cons (NULL_TREE, build_class_ref (class),
10868                               build_tree_list (NULL_TREE,
10869                                                size_in_bytes (class))),
10870                    NULL_TREE);
10871       saved_new = save_expr (new);
10872       c1 = build_tree_list (NULL_TREE, saved_new);
10873       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10874       TREE_OPERAND (original_call, 1) = c1;
10875       TREE_SET_CODE (original_call, CALL_EXPR);
10876       patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10877     }
10878
10879   /* If CHECK is set, then we are building a check to see if the object
10880      is NULL.  */
10881   if (check != NULL_TREE)
10882     {
10883       /* We have to call force_evaluation_order now because creating a
10884          COMPOUND_EXPR wraps the arg list in a way that makes it
10885          unrecognizable by force_evaluation_order later.  Yuk.  */
10886       patch = build (COMPOUND_EXPR, TREE_TYPE (patch), check,
10887                      force_evaluation_order (patch));
10888       TREE_SIDE_EFFECTS (patch) = 1;
10889     }
10890
10891   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10892      put it as the first expression of a COMPOUND_EXPR. The second
10893      expression being an empty statement to be later patched if
10894      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10895      the VALUE is the compound) in a hashtable and return a
10896      COMPOUND_EXPR built so that the result of the evaluation of the
10897      original PATCH node is returned. */
10898   if (STATIC_CLASS_INIT_OPT_P ()
10899       && current_function_decl && METHOD_STATIC (method))
10900     {
10901       tree list;
10902       tree fndecl = current_function_decl;
10903       /* We have to call force_evaluation_order now because creating a
10904          COMPOUND_EXPR wraps the arg list in a way that makes it
10905          unrecognizable by force_evaluation_order later.  Yuk.  */
10906       tree save = save_expr (force_evaluation_order (patch));
10907       tree type = TREE_TYPE (patch);
10908
10909       patch = build (COMPOUND_EXPR, type, save, empty_stmt_node);
10910       list = tree_cons (method, patch,
10911                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10912
10913       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10914
10915       patch = build (COMPOUND_EXPR, type, patch, save);
10916     }
10917
10918   return patch;
10919 }
10920
10921 static int
10922 invocation_mode (tree method, int super)
10923 {
10924   int access = get_access_flags_from_decl (method);
10925
10926   if (super)
10927     return INVOKE_SUPER;
10928
10929   if (access & ACC_STATIC)
10930     return INVOKE_STATIC;
10931
10932   /* We have to look for a constructor before we handle nonvirtual
10933      calls; otherwise the constructor will look nonvirtual.  */
10934   if (DECL_CONSTRUCTOR_P (method))
10935     return INVOKE_STATIC;
10936
10937   if (access & ACC_FINAL || access & ACC_PRIVATE)
10938     return INVOKE_NONVIRTUAL;
10939
10940   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10941     return INVOKE_NONVIRTUAL;
10942
10943   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10944     return INVOKE_INTERFACE;
10945
10946   return INVOKE_VIRTUAL;
10947 }
10948
10949 /* Retrieve a refined list of matching methods. It covers the step
10950    15.11.2 (Compile-Time Step 2) */
10951
10952 static tree
10953 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
10954 {
10955   tree atl = end_params_node;           /* Arg Type List */
10956   tree method, signature, list, node;
10957   const char *candidates;               /* Used for error report */
10958   char *dup;
10959
10960   /* Fix the arguments */
10961   for (node = arg_list; node; node = TREE_CHAIN (node))
10962     {
10963       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10964       /* Non primitive type may have to be resolved */
10965       if (!JPRIMITIVE_TYPE_P (current_arg))
10966         resolve_and_layout (current_arg, NULL_TREE);
10967       /* And promoted */
10968       if (TREE_CODE (current_arg) == RECORD_TYPE)
10969         current_arg = promote_type (current_arg);
10970       atl = tree_cons (NULL_TREE, current_arg, atl);
10971     }
10972
10973   /* Presto. If we're dealing with an anonymous class and a
10974      constructor call, generate the right constructor now, since we
10975      know the arguments' types. */
10976
10977   if (lc && ANONYMOUS_CLASS_P (class))
10978     {
10979       tree saved_current_class;
10980       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10981       saved_current_class = current_class;
10982       current_class = class;
10983       fix_constructors (mdecl);
10984       current_class = saved_current_class;
10985     }
10986
10987   /* Find all candidates and then refine the list, searching for the
10988      most specific method. */
10989   list = find_applicable_accessible_methods_list (lc, class, name, atl);
10990   list = find_most_specific_methods_list (list);
10991   if (list && !TREE_CHAIN (list))
10992     return TREE_VALUE (list);
10993
10994   /* Issue an error. List candidates if any. Candidates are listed
10995      only if accessible (non accessible methods may end-up here for
10996      the sake of a better error report). */
10997   candidates = NULL;
10998   if (list)
10999     {
11000       tree current;
11001       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
11002       for (current = list; current; current = TREE_CHAIN (current))
11003         {
11004           tree cm = TREE_VALUE (current);
11005           char string [4096];
11006           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
11007             continue;
11008           sprintf
11009             (string, "  `%s' in `%s'%s",
11010              get_printable_method_name (cm),
11011              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
11012              (TREE_CHAIN (current) ? "\n" : ""));
11013           obstack_grow (&temporary_obstack, string, strlen (string));
11014         }
11015       obstack_1grow (&temporary_obstack, '\0');
11016       candidates = obstack_finish (&temporary_obstack);
11017     }
11018   /* Issue the error message */
11019   method = make_node (FUNCTION_TYPE);
11020   TYPE_ARG_TYPES (method) = atl;
11021   signature = build_java_argument_signature (method);
11022   dup = xstrdup (lang_printable_name (class, 0));
11023   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
11024                        (lc ? "constructor" : "method"),
11025                        (lc ? dup : IDENTIFIER_POINTER (name)),
11026                        IDENTIFIER_POINTER (signature), dup,
11027                        (candidates ? candidates : ""));
11028   free (dup);
11029   return NULL_TREE;
11030 }
11031
11032 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
11033    when we're looking for a constructor. */
11034
11035 static tree
11036 find_applicable_accessible_methods_list (int lc, tree class, tree name,
11037                                          tree arglist)
11038 {
11039   static htab_t searched_classes;
11040   static int search_not_done = 0;
11041   tree list = NULL_TREE, all_list = NULL_TREE;
11042
11043   /* Check the hash table to determine if this class has been searched
11044      already. */
11045   if (searched_classes)
11046     {
11047       if (htab_find (searched_classes, class) != NULL)
11048         return NULL;
11049     }
11050   else
11051     {
11052       searched_classes = htab_create (10, htab_hash_pointer,
11053                                       htab_eq_pointer, NULL);
11054     }
11055
11056   search_not_done++;
11057   *htab_find_slot (searched_classes, class, INSERT) = class;
11058
11059   if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
11060     {
11061       load_class (class, 1);
11062       safe_layout_class (class);
11063     }
11064
11065   /* Search interfaces */
11066   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11067       && CLASS_INTERFACE (TYPE_NAME (class)))
11068     {
11069       int i, n;
11070       tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11071       search_applicable_methods_list (lc, TYPE_METHODS (class),
11072                                       name, arglist, &list, &all_list);
11073       n = TREE_VEC_LENGTH (basetype_vec);
11074       for (i = 1; i < n; i++)
11075         {
11076           tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11077           tree rlist;
11078
11079           rlist = find_applicable_accessible_methods_list (lc,  t, name,
11080                                                            arglist);
11081           list = chainon (rlist, list);
11082         }
11083     }
11084   /* Search classes */
11085   else
11086     {
11087       search_applicable_methods_list (lc, TYPE_METHODS (class),
11088                                       name, arglist, &list, &all_list);
11089
11090       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11091          that we only search in class. Note that we should have found
11092          something at this point. */
11093       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11094         {
11095           lc = 1;
11096           if (!list)
11097             abort ();
11098         }
11099
11100       /* We must search all interfaces of this class */
11101       if (!lc)
11102       {
11103         tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11104         int n = TREE_VEC_LENGTH (basetype_vec), i;
11105         for (i = 1; i < n; i++)
11106           {
11107             tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11108             if (t != object_type_node)
11109               {
11110                 tree rlist
11111                   = find_applicable_accessible_methods_list (lc, t,
11112                                                              name, arglist);
11113                 list = chainon (rlist, list);
11114               }
11115           }
11116       }
11117
11118       /* Search superclass */
11119       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11120         {
11121           tree rlist;
11122           class = CLASSTYPE_SUPER (class);
11123           rlist = find_applicable_accessible_methods_list (lc, class,
11124                                                            name, arglist);
11125           list = chainon (rlist, list);
11126         }
11127     }
11128
11129   search_not_done--;
11130
11131   /* We're done. Reset the searched classes list and finally search
11132      java.lang.Object if it wasn't searched already. */
11133   if (!search_not_done)
11134     {
11135       if (!lc
11136           && TYPE_METHODS (object_type_node)
11137           && htab_find (searched_classes, object_type_node) == NULL)
11138         {
11139           search_applicable_methods_list (lc,
11140                                           TYPE_METHODS (object_type_node),
11141                                           name, arglist, &list, &all_list);
11142         }
11143       htab_delete (searched_classes);
11144       searched_classes = NULL;
11145     }
11146
11147   /* Either return the list obtained or all selected (but
11148      inaccessible) methods for better error report. */
11149   return (!list ? all_list : list);
11150 }
11151
11152 /* Effectively search for the appropriate method in method */
11153
11154 static void
11155 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11156                                 tree *list, tree *all_list)
11157 {
11158   for (; method; method = TREE_CHAIN (method))
11159     {
11160       /* When dealing with constructor, stop here, otherwise search
11161          other classes */
11162       if (lc && !DECL_CONSTRUCTOR_P (method))
11163         continue;
11164       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11165                        || (DECL_NAME (method) != name)))
11166         continue;
11167
11168       if (argument_types_convertible (method, arglist))
11169         {
11170           /* Retain accessible methods only */
11171           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11172                                  method, NULL_TREE, 0))
11173             *list = tree_cons (NULL_TREE, method, *list);
11174           else
11175             /* Also retain all selected method here */
11176             *all_list = tree_cons (NULL_TREE, method, *list);
11177         }
11178     }
11179 }
11180
11181 /* 15.11.2.2 Choose the Most Specific Method */
11182
11183 static tree
11184 find_most_specific_methods_list (tree list)
11185 {
11186   int max = 0;
11187   int abstract, candidates;
11188   tree current, new_list = NULL_TREE;
11189   for (current = list; current; current = TREE_CHAIN (current))
11190     {
11191       tree method;
11192       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11193
11194       for (method = list; method; method = TREE_CHAIN (method))
11195         {
11196           tree method_v, current_v;
11197           /* Don't test a method against itself */
11198           if (method == current)
11199             continue;
11200
11201           method_v = TREE_VALUE (method);
11202           current_v = TREE_VALUE (current);
11203
11204           /* Compare arguments and location where methods where declared */
11205           if (argument_types_convertible (method_v, current_v))
11206             {
11207               if (valid_method_invocation_conversion_p
11208                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11209                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11210                       && enclosing_context_p (DECL_CONTEXT (method_v),
11211                                               DECL_CONTEXT (current_v))))
11212                 {
11213                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
11214                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11215                   max = (v > max ? v : max);
11216                 }
11217             }
11218         }
11219     }
11220
11221   /* Review the list and select the maximally specific methods */
11222   for (current = list, abstract = -1, candidates = -1;
11223        current; current = TREE_CHAIN (current))
11224     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11225       {
11226         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11227         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11228         candidates++;
11229       }
11230
11231   /* If we have several and they're all abstract, just pick the
11232      closest one. */
11233   if (candidates > 0 && candidates == abstract)
11234     {
11235       /* FIXME: merge the throws clauses.  There is no convenient way
11236          to do this in gcj right now, since ideally we'd like to
11237          introduce a new METHOD_DECL here, but that is really not
11238          possible.  */
11239       new_list = nreverse (new_list);
11240       TREE_CHAIN (new_list) = NULL_TREE;
11241       return new_list;
11242     }
11243
11244   /* We have several (we couldn't find a most specific), all but one
11245      are abstract, we pick the only non abstract one. */
11246   if (candidates > 0 && (candidates == abstract+1))
11247     {
11248       for (current = new_list; current; current = TREE_CHAIN (current))
11249         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11250           {
11251             TREE_CHAIN (current) = NULL_TREE;
11252             new_list = current;
11253           }
11254     }
11255
11256   /* If we can't find one, lower expectations and try to gather multiple
11257      maximally specific methods */
11258   while (!new_list && max)
11259     {
11260       while (--max > 0)
11261         {
11262           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11263             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11264         }
11265     }
11266
11267   return new_list;
11268 }
11269
11270 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11271    converted by method invocation conversion (5.3) to the type of the
11272    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11273    to change less often than M1. */
11274
11275 static GTY(()) tree m2_arg_value;
11276 static GTY(()) tree m2_arg_cache;
11277
11278 static int
11279 argument_types_convertible (tree m1, tree m2_or_arglist)
11280 {
11281   tree m1_arg, m2_arg;
11282
11283   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11284
11285   if (m2_arg_value == m2_or_arglist)
11286     m2_arg = m2_arg_cache;
11287   else
11288     {
11289       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11290          argument types */
11291       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11292         {
11293           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11294           if (!METHOD_STATIC (m2_or_arglist))
11295             m2_arg = TREE_CHAIN (m2_arg);
11296         }
11297       else
11298         m2_arg = m2_or_arglist;
11299
11300       m2_arg_value = m2_or_arglist;
11301       m2_arg_cache = m2_arg;
11302     }
11303
11304   while (m1_arg != end_params_node && m2_arg != end_params_node)
11305     {
11306       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11307       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11308                                                  TREE_VALUE (m2_arg)))
11309         break;
11310       m1_arg = TREE_CHAIN (m1_arg);
11311       m2_arg = TREE_CHAIN (m2_arg);
11312     }
11313   return m1_arg == end_params_node && m2_arg == end_params_node;
11314 }
11315
11316 /* Qualification routines */
11317
11318 /* Given a name x.y.z, look up x locally.  If it's found, save the
11319    decl.  If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11320    so that we later try and load the appropriate classes.  */
11321 static void
11322 qualify_ambiguous_name (tree id)
11323 {
11324   tree name, decl;
11325
11326   /* We inspect the first item of the qualification list.  As a sanity
11327      check, make sure that it is an identfier node.  */
11328   tree qual = EXPR_WFL_QUALIFICATION (id);
11329   tree qual_wfl = QUAL_WFL (qual);
11330
11331   if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11332     return;
11333
11334   name = EXPR_WFL_NODE (qual_wfl);
11335
11336   /* If we don't have an identifier, or we have a 'this' or 'super',
11337      then field access processing is all we need : there is nothing
11338      for us to do.  */
11339   if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11340       name == this_identifier_node ||
11341       name == super_identifier_node)
11342     return;
11343
11344   /* If name appears within the scope of a local variable declaration
11345      or parameter declaration, or is a field within an enclosing
11346      class, then it is an expression name.  Save the decl and let
11347      resolve_field_access do it's work.  */
11348   if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11349       (decl = lookup_field_wrapper (current_class, name)))
11350     {
11351       QUAL_RESOLUTION (qual) = decl;
11352       return;
11353     }
11354
11355   /* If name is a known class name (either declared or imported), mark
11356      us as a type name.  */
11357   if ((decl = resolve_and_layout (name, NULL_TREE)))
11358     {
11359       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11360       QUAL_RESOLUTION (qual) = decl;
11361     }
11362
11363   /* Check here that NAME isn't declared by more than one
11364      type-import-on-demand declaration of the compilation unit
11365      containing NAME. FIXME */
11366
11367   /* We couldn't find a declaration for the name.  Assume for now that
11368      we have a qualified class name that needs to be loaded from an
11369      external class file.  */
11370   else
11371     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11372
11373   /* Propagate the qualification across other components of the
11374      qualified name */
11375   for (qual = TREE_CHAIN (qual); qual;
11376        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11377     {
11378       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11379         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11380     }
11381
11382   /* Store the global qualification for the ambiguous part of ID back
11383      into ID fields */
11384   if (RESOLVE_TYPE_NAME_P (qual_wfl))
11385     RESOLVE_TYPE_NAME_P (id) = 1;
11386   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11387     RESOLVE_PACKAGE_NAME_P (id) = 1;
11388 }
11389
11390 static int
11391 breakdown_qualified (tree *left, tree *right, tree source)
11392 {
11393   char *p, *base;
11394   int l = IDENTIFIER_LENGTH (source);
11395
11396   base = alloca (l + 1);
11397   memcpy (base, IDENTIFIER_POINTER (source), l + 1);
11398
11399   /* Breakdown NAME into REMAINDER . IDENTIFIER.  */
11400   p = base + l - 1;
11401   while (*p != '.' && p != base)
11402     p--;
11403
11404   /* We didn't find a '.'. Return an error.  */
11405   if (p == base)
11406     return 1;
11407
11408   *p = '\0';
11409   if (right)
11410     *right = get_identifier (p+1);
11411   *left = get_identifier (base);
11412
11413   return 0;
11414 }
11415
11416 /* Return TRUE if two classes are from the same package. */
11417
11418 static int
11419 in_same_package (tree name1, tree name2)
11420 {
11421   tree tmp;
11422   tree pkg1;
11423   tree pkg2;
11424
11425   if (TREE_CODE (name1) == TYPE_DECL)
11426     name1 = DECL_NAME (name1);
11427   if (TREE_CODE (name2) == TYPE_DECL)
11428     name2 = DECL_NAME (name2);
11429
11430   if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
11431     /* One in empty package. */
11432     return 0;
11433
11434   if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
11435     /* Both in empty package. */
11436     return 1;
11437
11438   breakdown_qualified (&pkg1, &tmp, name1);
11439   breakdown_qualified (&pkg2, &tmp, name2);
11440
11441   return (pkg1 == pkg2);
11442 }
11443
11444 /* Patch tree nodes in a function body. When a BLOCK is found, push
11445    local variable decls if present.
11446    Same as java_complete_lhs, but does resolve static finals to values. */
11447
11448 static tree
11449 java_complete_tree (tree node)
11450 {
11451   node = java_complete_lhs (node);
11452   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11453       && DECL_INITIAL (node) != NULL_TREE
11454       && !flag_emit_xref)
11455     {
11456       tree value = fold_constant_for_init (node, node);
11457       if (value != NULL_TREE)
11458         return value;
11459     }
11460   return node;
11461 }
11462
11463 static tree
11464 java_stabilize_reference (tree node)
11465 {
11466   if (TREE_CODE (node) == COMPOUND_EXPR)
11467     {
11468       tree op0 = TREE_OPERAND (node, 0);
11469       tree op1 = TREE_OPERAND (node, 1);
11470       TREE_OPERAND (node, 0) = save_expr (op0);
11471       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11472       return node;
11473     }
11474   return stabilize_reference (node);
11475 }
11476
11477 /* Patch tree nodes in a function body. When a BLOCK is found, push
11478    local variable decls if present.
11479    Same as java_complete_tree, but does not resolve static finals to values. */
11480
11481 static tree
11482 java_complete_lhs (tree node)
11483 {
11484   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11485   int flag;
11486
11487   /* CONVERT_EXPR always has its type set, even though it needs to be
11488      worked out. */
11489   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11490     return node;
11491
11492   /* The switch block implements cases processing container nodes
11493      first.  Contained nodes are always written back. Leaves come
11494      next and return a value. */
11495   switch (TREE_CODE (node))
11496     {
11497     case BLOCK:
11498
11499       /* 1- Block section.
11500          Set the local values on decl names so we can identify them
11501          faster when they're referenced. At that stage, identifiers
11502          are legal so we don't check for declaration errors. */
11503       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11504         {
11505           DECL_CONTEXT (cn) = current_function_decl;
11506           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11507         }
11508       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11509           CAN_COMPLETE_NORMALLY (node) = 1;
11510       else
11511         {
11512           tree stmt = BLOCK_EXPR_BODY (node);
11513           tree *ptr;
11514           int error_seen = 0;
11515           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11516             {
11517               /* Re-order from (((A; B); C); ...; Z) to
11518                  (A; (B; (C ; (...; Z)))).
11519                  This makes it easier to scan the statements left-to-right
11520                  without using recursion (which might overflow the stack
11521                  if the block has many statements. */
11522               for (;;)
11523                 {
11524                   tree left = TREE_OPERAND (stmt, 0);
11525                   if (TREE_CODE (left) != COMPOUND_EXPR)
11526                     break;
11527                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11528                   TREE_OPERAND (left, 1) = stmt;
11529                   stmt = left;
11530                 }
11531               BLOCK_EXPR_BODY (node) = stmt;
11532             }
11533
11534           /* Now do the actual complete, without deep recursion for
11535              long blocks. */
11536           ptr = &BLOCK_EXPR_BODY (node);
11537           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11538                  && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
11539             {
11540               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11541               tree *next = &TREE_OPERAND (*ptr, 1);
11542               TREE_OPERAND (*ptr, 0) = cur;
11543               if (cur == empty_stmt_node)
11544                 {
11545                   /* Optimization;  makes it easier to detect empty bodies.
11546                      Most useful for <clinit> with all-constant initializer. */
11547                   *ptr = *next;
11548                   continue;
11549                 }
11550               if (TREE_CODE (cur) == ERROR_MARK)
11551                 error_seen++;
11552               else if (! CAN_COMPLETE_NORMALLY (cur))
11553                 {
11554                   wfl_op2 = *next;
11555                   for (;;)
11556                     {
11557                       if (TREE_CODE (wfl_op2) == BLOCK)
11558                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11559                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11560                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11561                       else
11562                         break;
11563                     }
11564                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11565                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11566                     unreachable_stmt_error (*ptr);
11567                 }
11568               if (TREE_TYPE (*ptr) == NULL_TREE)
11569                 TREE_TYPE (*ptr) = void_type_node;
11570               ptr = next;
11571             }
11572           *ptr = java_complete_tree (*ptr);
11573
11574           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11575             return error_mark_node;
11576           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11577         }
11578       /* Turn local bindings to null */
11579       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11580         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11581
11582       TREE_TYPE (node) = void_type_node;
11583       break;
11584
11585       /* 2- They are expressions but ultimately deal with statements */
11586
11587     case THROW_EXPR:
11588       wfl_op1 = TREE_OPERAND (node, 0);
11589       COMPLETE_CHECK_OP_0 (node);
11590       /* 14.19 A throw statement cannot complete normally. */
11591       CAN_COMPLETE_NORMALLY (node) = 0;
11592       return patch_throw_statement (node, wfl_op1);
11593
11594     case SYNCHRONIZED_EXPR:
11595       wfl_op1 = TREE_OPERAND (node, 0);
11596       return patch_synchronized_statement (node, wfl_op1);
11597
11598     case TRY_EXPR:
11599       return patch_try_statement (node);
11600
11601     case TRY_FINALLY_EXPR:
11602       COMPLETE_CHECK_OP_0 (node);
11603       COMPLETE_CHECK_OP_1 (node);
11604       /* Reduce try/finally nodes with an empty try block.  */
11605       if (TREE_OPERAND (node, 0) == empty_stmt_node
11606           || BLOCK_EMPTY_P (TREE_OPERAND (node, 0)))
11607         return TREE_OPERAND (node, 1);
11608       /* Likewise for an empty finally block.  */
11609       if (TREE_OPERAND (node, 1) == empty_stmt_node
11610           || BLOCK_EMPTY_P (TREE_OPERAND (node, 1)))
11611         return TREE_OPERAND (node, 0);
11612       CAN_COMPLETE_NORMALLY (node)
11613         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11614            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11615       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11616       return node;
11617
11618     case LABELED_BLOCK_EXPR:
11619       PUSH_LABELED_BLOCK (node);
11620       if (LABELED_BLOCK_BODY (node))
11621         COMPLETE_CHECK_OP_1 (node);
11622       TREE_TYPE (node) = void_type_node;
11623       POP_LABELED_BLOCK ();
11624
11625       if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
11626         {
11627           LABELED_BLOCK_BODY (node) = NULL_TREE;
11628           CAN_COMPLETE_NORMALLY (node) = 1;
11629         }
11630       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11631         CAN_COMPLETE_NORMALLY (node) = 1;
11632       return node;
11633
11634     case EXIT_BLOCK_EXPR:
11635       /* We don't complete operand 1, because it's the return value of
11636          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11637       return patch_bc_statement (node);
11638
11639     case CASE_EXPR:
11640       cn = java_complete_tree (TREE_OPERAND (node, 0));
11641       if (cn == error_mark_node)
11642         return cn;
11643
11644       /* First, the case expression must be constant. Values of final
11645          fields are accepted. */
11646       cn = fold (cn);
11647       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11648           && JDECL_P (TREE_OPERAND (cn, 1))
11649           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11650           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11651         {
11652           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11653                                        TREE_OPERAND (cn, 1));
11654         }
11655       /* Accept final locals too. */
11656       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn))
11657         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11658
11659       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11660         {
11661           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11662           parse_error_context (node, "Constant expression required");
11663           return error_mark_node;
11664         }
11665
11666       nn = ctxp->current_loop;
11667
11668       /* It must be assignable to the type of the switch expression. */
11669       if (!try_builtin_assignconv (NULL_TREE,
11670                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11671         {
11672           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11673           parse_error_context
11674             (wfl_operator,
11675              "Incompatible type for case. Can't convert `%s' to `int'",
11676              lang_printable_name (TREE_TYPE (cn), 0));
11677           return error_mark_node;
11678         }
11679
11680       cn = fold (convert (int_type_node, cn));
11681       TREE_CONSTANT_OVERFLOW (cn) = 0;
11682       CAN_COMPLETE_NORMALLY (cn) = 1;
11683
11684       /* Save the label on a list so that we can later check for
11685          duplicates.  */
11686       case_label_list = tree_cons (node, cn, case_label_list);
11687
11688       /* Multiple instance of a case label bearing the same value is
11689          checked later. The case expression is all right so far. */
11690       if (TREE_CODE (cn) == VAR_DECL)
11691         cn = DECL_INITIAL (cn);
11692       TREE_OPERAND (node, 0) = cn;
11693       TREE_TYPE (node) = void_type_node;
11694       CAN_COMPLETE_NORMALLY (node) = 1;
11695       TREE_SIDE_EFFECTS (node) = 1;
11696       break;
11697
11698     case DEFAULT_EXPR:
11699       nn = ctxp->current_loop;
11700       /* Only one default label is allowed per switch statement */
11701       if (SWITCH_HAS_DEFAULT (nn))
11702         {
11703           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11704           parse_error_context (wfl_operator,
11705                                "Duplicate case label: `default'");
11706           return error_mark_node;
11707         }
11708       else
11709         SWITCH_HAS_DEFAULT (nn) = 1;
11710       TREE_TYPE (node) = void_type_node;
11711       TREE_SIDE_EFFECTS (node) = 1;
11712       CAN_COMPLETE_NORMALLY (node) = 1;
11713       break;
11714
11715     case SWITCH_EXPR:
11716     case LOOP_EXPR:
11717       PUSH_LOOP (node);
11718       /* Check whether the loop was enclosed in a labeled
11719          statement. If not, create one, insert the loop in it and
11720          return the node */
11721       nn = patch_loop_statement (node);
11722
11723       /* Anyways, walk the body of the loop */
11724       if (TREE_CODE (node) == LOOP_EXPR)
11725         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11726       /* Switch statement: walk the switch expression and the cases */
11727       else
11728         node = patch_switch_statement (node);
11729
11730       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11731         nn = error_mark_node;
11732       else
11733         {
11734           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11735           /* If we returned something different, that's because we
11736              inserted a label. Pop the label too. */
11737           if (nn != node)
11738             {
11739               if (CAN_COMPLETE_NORMALLY (node))
11740                 CAN_COMPLETE_NORMALLY (nn) = 1;
11741               POP_LABELED_BLOCK ();
11742             }
11743         }
11744       POP_LOOP ();
11745       return nn;
11746
11747     case EXIT_EXPR:
11748       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11749       return patch_exit_expr (node);
11750
11751     case COND_EXPR:
11752       /* Condition */
11753       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11754       if (TREE_OPERAND (node, 0) == error_mark_node)
11755         return error_mark_node;
11756       /* then-else branches */
11757       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11758       if (TREE_OPERAND (node, 1) == error_mark_node)
11759         return error_mark_node;
11760       TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11761       if (TREE_OPERAND (node, 2) == error_mark_node)
11762         return error_mark_node;
11763       return patch_if_else_statement (node);
11764       break;
11765
11766     case CONDITIONAL_EXPR:
11767       /* Condition */
11768       wfl_op1 = TREE_OPERAND (node, 0);
11769       COMPLETE_CHECK_OP_0 (node);
11770       wfl_op2 = TREE_OPERAND (node, 1);
11771       COMPLETE_CHECK_OP_1 (node);
11772       wfl_op3 = TREE_OPERAND (node, 2);
11773       COMPLETE_CHECK_OP_2 (node);
11774       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11775
11776       /* 3- Expression section */
11777     case COMPOUND_EXPR:
11778       wfl_op2 = TREE_OPERAND (node, 1);
11779       TREE_OPERAND (node, 0) = nn =
11780         java_complete_tree (TREE_OPERAND (node, 0));
11781       if (wfl_op2 == empty_stmt_node)
11782         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11783       else
11784         {
11785           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11786             {
11787               /* An unreachable condition in a do-while statement
11788                  is *not* (technically) an unreachable statement. */
11789               nn = wfl_op2;
11790               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11791                 nn = EXPR_WFL_NODE (nn);
11792               /* NN can be NULL_TREE exactly when UPDATE is, in
11793                  finish_for_loop.  */
11794               if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11795                 {
11796                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11797                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11798                     {
11799                       /* Perhaps this warning should have an
11800                          associated flag.  The code being compiled is
11801                          pedantically correct, but useless.  */
11802                       parse_warning_context (wfl_operator,
11803                                              "Unreachable statement");
11804                     }
11805                   else
11806                     parse_error_context (wfl_operator,
11807                                          "Unreachable statement");
11808                 }
11809             }
11810           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11811           if (TREE_OPERAND (node, 1) == error_mark_node)
11812             return error_mark_node;
11813           /* Even though we might allow the case where the first
11814              operand doesn't return normally, we still should compute
11815              CAN_COMPLETE_NORMALLY correctly.  */
11816           CAN_COMPLETE_NORMALLY (node)
11817             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11818                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11819         }
11820       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11821       break;
11822
11823     case RETURN_EXPR:
11824       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11825       return patch_return (node);
11826
11827     case EXPR_WITH_FILE_LOCATION:
11828       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11829           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11830         {
11831           tree wfl = node;
11832           node = resolve_expression_name (node, NULL);
11833           if (node == error_mark_node)
11834             return node;
11835           /* Keep line number information somewhere were it doesn't
11836              disrupt the completion process. */
11837           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11838             {
11839               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11840               TREE_OPERAND (node, 1) = wfl;
11841             }
11842           CAN_COMPLETE_NORMALLY (node) = 1;
11843         }
11844       else
11845         {
11846           tree body;
11847           int save_lineno = input_line;
11848           input_line = EXPR_WFL_LINENO (node);
11849           body = java_complete_tree (EXPR_WFL_NODE (node));
11850           input_line = save_lineno;
11851           EXPR_WFL_NODE (node) = body;
11852           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11853           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11854           if (body == empty_stmt_node || TREE_CONSTANT (body))
11855             {
11856               /* Makes it easier to constant fold, detect empty bodies. */
11857               return body;
11858             }
11859           if (body == error_mark_node)
11860             {
11861               /* Its important for the evaluation of assignment that
11862                  this mark on the TREE_TYPE is propagated. */
11863               TREE_TYPE (node) = error_mark_node;
11864               return error_mark_node;
11865             }
11866           else
11867             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11868
11869         }
11870       break;
11871
11872     case NEW_ARRAY_EXPR:
11873       /* Patch all the dimensions */
11874       flag = 0;
11875       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11876         {
11877           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11878           tree dim = convert (int_type_node,
11879                               java_complete_tree (TREE_VALUE (cn)));
11880           if (dim == error_mark_node)
11881             {
11882               flag = 1;
11883               continue;
11884             }
11885           else
11886             {
11887               TREE_VALUE (cn) = dim;
11888               /* Setup the location of the current dimension, for
11889                  later error report. */
11890               TREE_PURPOSE (cn) =
11891                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11892               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11893             }
11894         }
11895       /* They complete the array creation expression, if no errors
11896          were found. */
11897       CAN_COMPLETE_NORMALLY (node) = 1;
11898       return (flag ? error_mark_node
11899               : force_evaluation_order (patch_newarray (node)));
11900
11901     case NEW_ANONYMOUS_ARRAY_EXPR:
11902       /* Create the array type if necessary. */
11903       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11904         {
11905           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11906           if (!(type = resolve_type_during_patch (type)))
11907             return error_mark_node;
11908           type = build_array_from_name (type, NULL_TREE,
11909                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11910           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11911         }
11912       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11913                                    ANONYMOUS_ARRAY_INITIALIZER (node));
11914       if (node == error_mark_node)
11915         return error_mark_node;
11916       CAN_COMPLETE_NORMALLY (node) = 1;
11917       return node;
11918
11919     case NEW_CLASS_EXPR:
11920     case CALL_EXPR:
11921       /* Complete function's argument(s) first */
11922       if (complete_function_arguments (node))
11923         return error_mark_node;
11924       else
11925         {
11926           tree decl, wfl = TREE_OPERAND (node, 0);
11927           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11928           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11929                            super_identifier_node);
11930           tree arguments;
11931           int location = EXPR_WFL_LINECOL (node);
11932
11933           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11934                                           from_super, 0, &decl);
11935           if (node == error_mark_node)
11936             return error_mark_node;
11937
11938           if (TREE_CODE (node) == CALL_EXPR
11939               && TREE_OPERAND (node, 1) != NULL_TREE)
11940             arguments = TREE_VALUE (TREE_OPERAND (node, 1));
11941           else
11942             arguments = NULL_TREE;
11943           check_thrown_exceptions (location, decl, arguments);
11944           /* If we call this(...), register signature and positions */
11945           if (in_this)
11946             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11947               tree_cons (wfl, decl,
11948                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
11949           CAN_COMPLETE_NORMALLY (node) = 1;
11950           return force_evaluation_order (node);
11951         }
11952
11953     case MODIFY_EXPR:
11954       /* Save potential wfls */
11955       wfl_op1 = TREE_OPERAND (node, 0);
11956       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11957
11958       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11959           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11960           && DECL_INITIAL (nn) != NULL_TREE)
11961         {
11962           tree value;
11963
11964           value = fold_constant_for_init (nn, nn);
11965
11966           /* When we have a primitype type, or a string and we're not
11967              emitting a class file, we actually don't want to generate
11968              anything for the assignment. */
11969           if (value != NULL_TREE &&
11970               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
11971                (TREE_TYPE (value) == string_ptr_type_node &&
11972                 ! flag_emit_class_files)))
11973             {
11974               /* Prepare node for patch_assignment */
11975               TREE_OPERAND (node, 1) = value;
11976               /* Call patch assignment to verify the assignment */
11977               if (patch_assignment (node, wfl_op1) == error_mark_node)
11978                 return error_mark_node;
11979               /* Set DECL_INITIAL properly (a conversion might have
11980                  been decided by patch_assignment) and return the
11981                  empty statement. */
11982               else
11983                 {
11984                   tree patched = patch_string (TREE_OPERAND (node, 1));
11985                   if (patched)
11986                     DECL_INITIAL (nn) = patched;
11987                   else
11988                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11989                   DECL_FIELD_FINAL_IUD (nn) = 1;
11990                   return empty_stmt_node;
11991                 }
11992             }
11993           if (! flag_emit_class_files)
11994             DECL_INITIAL (nn) = NULL_TREE;
11995         }
11996       wfl_op2 = TREE_OPERAND (node, 1);
11997
11998       if (TREE_OPERAND (node, 0) == error_mark_node)
11999         return error_mark_node;
12000
12001       flag = COMPOUND_ASSIGN_P (wfl_op2);
12002       if (flag)
12003         {
12004           /* This might break when accessing outer field from inner
12005              class. TESTME, FIXME */
12006           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
12007
12008           /* Hand stabilize the lhs on both places */
12009           TREE_OPERAND (node, 0) = lvalue;
12010           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
12011             (flag_emit_class_files ? lvalue : save_expr (lvalue));
12012
12013           /* 15.25.2.a: Left hand is not an array access. FIXME */
12014           /* Now complete the RHS. We write it back later on. */
12015           nn = java_complete_tree (TREE_OPERAND (node, 1));
12016
12017           if ((cn = patch_string (nn)))
12018             nn = cn;
12019
12020           /* The last part of the rewrite for E1 op= E2 is to have
12021              E1 = (T)(E1 op E2), with T being the type of E1. */
12022           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
12023                                                TREE_TYPE (lvalue), nn));
12024
12025           /* If the assignment is compound and has reference type,
12026              then ensure the LHS has type String and nothing else.  */
12027           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
12028               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
12029             parse_error_context (wfl_op2,
12030                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
12031                                  lang_printable_name (TREE_TYPE (lvalue), 0));
12032
12033           /* 15.25.2.b: Left hand is an array access. FIXME */
12034         }
12035
12036       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12037          function to complete this RHS. Note that a NEW_ARRAY_INIT
12038          might have been already fully expanded if created as a result
12039          of processing an anonymous array initializer. We avoid doing
12040          the operation twice by testing whether the node already bears
12041          a type. */
12042       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12043         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12044                                    TREE_OPERAND (node, 1));
12045       /* Otherwise we simply complete the RHS */
12046       else
12047         nn = java_complete_tree (TREE_OPERAND (node, 1));
12048
12049       if (nn == error_mark_node)
12050         return error_mark_node;
12051
12052       /* Write back the RHS as we evaluated it. */
12053       TREE_OPERAND (node, 1) = nn;
12054
12055       /* In case we're handling = with a String as a RHS, we need to
12056          produce a String out of the RHS (it might still be a
12057          STRING_CST or a StringBuffer at this stage */
12058       if ((nn = patch_string (TREE_OPERAND (node, 1))))
12059         TREE_OPERAND (node, 1) = nn;
12060
12061       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12062                                         TREE_OPERAND (node, 1))))
12063         {
12064           /* We return error_mark_node if outer_field_access_fix
12065              detects we write into a final. */
12066           if (nn == error_mark_node)
12067             return error_mark_node;
12068           node = nn;
12069         }
12070       else
12071         {
12072           node = patch_assignment (node, wfl_op1);
12073           if (node == error_mark_node)
12074             return error_mark_node;
12075           /* Reorganize the tree if necessary. */
12076           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12077                        || JSTRING_P (TREE_TYPE (node))))
12078             node = java_refold (node);
12079         }
12080
12081       /* Seek to set DECL_INITIAL to a proper value, since it might have
12082          undergone a conversion in patch_assignment. We do that only when
12083          it's necessary to have DECL_INITIAL properly set. */
12084       nn = TREE_OPERAND (node, 0);
12085       if (TREE_CODE (nn) == VAR_DECL
12086           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12087           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12088           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12089               || TREE_TYPE (nn) == string_ptr_type_node))
12090         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12091
12092       CAN_COMPLETE_NORMALLY (node) = 1;
12093       return node;
12094
12095     case MULT_EXPR:
12096     case PLUS_EXPR:
12097     case MINUS_EXPR:
12098     case LSHIFT_EXPR:
12099     case RSHIFT_EXPR:
12100     case URSHIFT_EXPR:
12101     case BIT_AND_EXPR:
12102     case BIT_XOR_EXPR:
12103     case BIT_IOR_EXPR:
12104     case TRUNC_MOD_EXPR:
12105     case TRUNC_DIV_EXPR:
12106     case RDIV_EXPR:
12107     case TRUTH_ANDIF_EXPR:
12108     case TRUTH_ORIF_EXPR:
12109     case EQ_EXPR:
12110     case NE_EXPR:
12111     case GT_EXPR:
12112     case GE_EXPR:
12113     case LT_EXPR:
12114     case LE_EXPR:
12115       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12116          knows how to handle those cases. */
12117       wfl_op1 = TREE_OPERAND (node, 0);
12118       wfl_op2 = TREE_OPERAND (node, 1);
12119
12120       CAN_COMPLETE_NORMALLY (node) = 1;
12121       /* Don't complete string nodes if dealing with the PLUS operand. */
12122       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12123         {
12124           nn = java_complete_tree (wfl_op1);
12125           if (nn == error_mark_node)
12126             return error_mark_node;
12127
12128           TREE_OPERAND (node, 0) = nn;
12129         }
12130       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12131         {
12132           nn = java_complete_tree (wfl_op2);
12133           if (nn == error_mark_node)
12134             return error_mark_node;
12135
12136           TREE_OPERAND (node, 1) = nn;
12137         }
12138       return patch_binop (node, wfl_op1, wfl_op2);
12139
12140     case INSTANCEOF_EXPR:
12141       wfl_op1 = TREE_OPERAND (node, 0);
12142       COMPLETE_CHECK_OP_0 (node);
12143       if (flag_emit_xref)
12144         {
12145           TREE_TYPE (node) = boolean_type_node;
12146           return node;
12147         }
12148       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12149
12150     case UNARY_PLUS_EXPR:
12151     case NEGATE_EXPR:
12152     case TRUTH_NOT_EXPR:
12153     case BIT_NOT_EXPR:
12154     case PREDECREMENT_EXPR:
12155     case PREINCREMENT_EXPR:
12156     case POSTDECREMENT_EXPR:
12157     case POSTINCREMENT_EXPR:
12158     case CONVERT_EXPR:
12159       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12160          how to handle those cases. */
12161       wfl_op1 = TREE_OPERAND (node, 0);
12162       CAN_COMPLETE_NORMALLY (node) = 1;
12163       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12164       if (TREE_OPERAND (node, 0) == error_mark_node)
12165         return error_mark_node;
12166       node = patch_unaryop (node, wfl_op1);
12167       CAN_COMPLETE_NORMALLY (node) = 1;
12168       break;
12169
12170     case ARRAY_REF:
12171       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12172          how to handle those cases. */
12173       wfl_op1 = TREE_OPERAND (node, 0);
12174       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12175       if (TREE_OPERAND (node, 0) == error_mark_node)
12176         return error_mark_node;
12177       if (!flag_emit_class_files && !flag_emit_xref)
12178         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12179       /* The same applies to wfl_op2 */
12180       wfl_op2 = TREE_OPERAND (node, 1);
12181       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12182       if (TREE_OPERAND (node, 1) == error_mark_node)
12183         return error_mark_node;
12184       if (!flag_emit_class_files && !flag_emit_xref)
12185         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12186       return patch_array_ref (node);
12187
12188     case RECORD_TYPE:
12189       return node;;
12190
12191     case COMPONENT_REF:
12192       /* The first step in the re-write of qualified name handling.  FIXME.
12193          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12194       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12195       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12196         {
12197           tree name = TREE_OPERAND (node, 1);
12198           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12199           if (field == NULL_TREE)
12200             {
12201               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12202               return error_mark_node;
12203             }
12204           if (! FIELD_STATIC (field))
12205             {
12206               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12207               return error_mark_node;
12208             }
12209           return field;
12210         }
12211       else
12212         abort ();
12213       break;
12214
12215     case THIS_EXPR:
12216       /* Can't use THIS in a static environment */
12217       if (!current_this)
12218         {
12219           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12220           parse_error_context (wfl_operator,
12221                                "Keyword `this' used outside allowed context");
12222           TREE_TYPE (node) = error_mark_node;
12223           return error_mark_node;
12224         }
12225       if (ctxp->explicit_constructor_p)
12226         {
12227           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12228           parse_error_context
12229             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12230           TREE_TYPE (node) = error_mark_node;
12231           return error_mark_node;
12232         }
12233       return current_this;
12234
12235     case CLASS_LITERAL:
12236       CAN_COMPLETE_NORMALLY (node) = 1;
12237       node = patch_incomplete_class_ref (node);
12238       if (node == error_mark_node)
12239         return error_mark_node;
12240       break;
12241
12242     default:
12243       CAN_COMPLETE_NORMALLY (node) = 1;
12244       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12245          and it's time to turn it into the appropriate String object */
12246       if ((nn = patch_string (node)))
12247         node = nn;
12248       else
12249         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12250     }
12251   return node;
12252 }
12253
12254 /* Complete function call's argument. Return a nonzero value is an
12255    error was found.  */
12256
12257 static int
12258 complete_function_arguments (tree node)
12259 {
12260   int flag = 0;
12261   tree cn;
12262
12263   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12264   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12265     {
12266       tree wfl = TREE_VALUE (cn), parm, temp;
12267       parm = java_complete_tree (wfl);
12268
12269       if (parm == error_mark_node)
12270         {
12271           flag = 1;
12272           continue;
12273         }
12274       /* If have a string literal that we haven't transformed yet or a
12275          crafted string buffer, as a result of use of the the String
12276          `+' operator. Build `parm.toString()' and expand it. */
12277       if ((temp = patch_string (parm)))
12278         parm = temp;
12279
12280       TREE_VALUE (cn) = parm;
12281     }
12282   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12283   return flag;
12284 }
12285
12286 /* Sometimes (for loops and variable initialized during their
12287    declaration), we want to wrap a statement around a WFL and turn it
12288    debugable.  */
12289
12290 static tree
12291 build_debugable_stmt (int location, tree stmt)
12292 {
12293   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12294     {
12295       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12296       EXPR_WFL_LINECOL (stmt) = location;
12297     }
12298   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12299   return stmt;
12300 }
12301
12302 static tree
12303 build_expr_block (tree body, tree decls)
12304
12305 {
12306   tree node = make_node (BLOCK);
12307   BLOCK_EXPR_DECLS (node) = decls;
12308   BLOCK_EXPR_BODY (node) = body;
12309   if (body)
12310     TREE_TYPE (node) = TREE_TYPE (body);
12311   TREE_SIDE_EFFECTS (node) = 1;
12312   return node;
12313 }
12314
12315 /* Create a new function block and link it appropriately to current
12316    function block chain */
12317
12318 static tree
12319 enter_block (void)
12320 {
12321   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12322
12323   /* Link block B supercontext to the previous block. The current
12324      function DECL is used as supercontext when enter_a_block is called
12325      for the first time for a given function. The current function body
12326      (DECL_FUNCTION_BODY) is set to be block B.  */
12327
12328   tree fndecl = current_function_decl;
12329
12330   if (!fndecl) {
12331     BLOCK_SUPERCONTEXT (b) = current_static_block;
12332     current_static_block = b;
12333   }
12334
12335   else if (!DECL_FUNCTION_BODY (fndecl))
12336     {
12337       BLOCK_SUPERCONTEXT (b) = fndecl;
12338       DECL_FUNCTION_BODY (fndecl) = b;
12339     }
12340   else
12341     {
12342       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12343       DECL_FUNCTION_BODY (fndecl) = b;
12344     }
12345   return b;
12346 }
12347
12348 /* Exit a block by changing the current function body
12349    (DECL_FUNCTION_BODY) to the current block super context, only if
12350    the block being exited isn't the method's top level one.  */
12351
12352 static tree
12353 exit_block (void)
12354 {
12355   tree b;
12356   if (current_function_decl)
12357     {
12358       b = DECL_FUNCTION_BODY (current_function_decl);
12359       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12360         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12361     }
12362   else
12363     {
12364       b = current_static_block;
12365
12366       if (BLOCK_SUPERCONTEXT (b))
12367         current_static_block = BLOCK_SUPERCONTEXT (b);
12368     }
12369   return b;
12370 }
12371
12372 /* Lookup for NAME in the nested function's blocks, all the way up to
12373    the current toplevel one. It complies with Java's local variable
12374    scoping rules.  */
12375
12376 static tree
12377 lookup_name_in_blocks (tree name)
12378 {
12379   tree b = GET_CURRENT_BLOCK (current_function_decl);
12380
12381   while (b != current_function_decl)
12382     {
12383       tree current;
12384
12385       /* Paranoid sanity check. To be removed */
12386       if (TREE_CODE (b) != BLOCK)
12387         abort ();
12388
12389       for (current = BLOCK_EXPR_DECLS (b); current;
12390            current = TREE_CHAIN (current))
12391         if (DECL_NAME (current) == name)
12392           return current;
12393       b = BLOCK_SUPERCONTEXT (b);
12394     }
12395   return NULL_TREE;
12396 }
12397
12398 static void
12399 maybe_absorb_scoping_blocks (void)
12400 {
12401   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12402     {
12403       tree b = exit_block ();
12404       java_method_add_stmt (current_function_decl, b);
12405       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12406     }
12407 }
12408
12409 \f
12410 /* This section of the source is reserved to build_* functions that
12411    are building incomplete tree nodes and the patch_* functions that
12412    are completing them.  */
12413
12414 /* Wrap a non WFL node around a WFL.  */
12415
12416 static tree
12417 build_wfl_wrap (tree node, int location)
12418 {
12419   tree wfl, node_to_insert = node;
12420
12421   /* We want to process THIS . xxx symbolically, to keep it consistent
12422      with the way we're processing SUPER. A THIS from a primary as a
12423      different form than a SUPER. Turn THIS into something symbolic */
12424   if (TREE_CODE (node) == THIS_EXPR)
12425     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12426   else
12427     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12428
12429   EXPR_WFL_LINECOL (wfl) = location;
12430   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12431   return wfl;
12432 }
12433
12434 /* Build a super() constructor invocation. Returns empty_stmt_node if
12435    we're currently dealing with the class java.lang.Object. */
12436
12437 static tree
12438 build_super_invocation (tree mdecl)
12439 {
12440   if (DECL_CONTEXT (mdecl) == object_type_node)
12441     return empty_stmt_node;
12442   else
12443     {
12444       tree super_wfl = build_wfl_node (super_identifier_node);
12445       tree a = NULL_TREE, t;
12446       /* If we're dealing with an anonymous class, pass the arguments
12447          of the crafted constructor along. */
12448       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12449         {
12450           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12451           for (; t != end_params_node; t = TREE_CHAIN (t))
12452             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12453         }
12454       return build_method_invocation (super_wfl, a);
12455     }
12456 }
12457
12458 /* Build a SUPER/THIS qualified method invocation.  */
12459
12460 static tree
12461 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12462                                        int lloc, int rloc)
12463 {
12464   tree invok;
12465   tree wfl =
12466     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12467   EXPR_WFL_LINECOL (wfl) = lloc;
12468   invok = build_method_invocation (name, args);
12469   return make_qualified_primary (wfl, invok, rloc);
12470 }
12471
12472 /* Build an incomplete CALL_EXPR node. */
12473
12474 static tree
12475 build_method_invocation (tree name, tree args)
12476 {
12477   tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12478   TREE_SIDE_EFFECTS (call) = 1;
12479   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12480   return call;
12481 }
12482
12483 /* Build an incomplete new xxx(...) node. */
12484
12485 static tree
12486 build_new_invocation (tree name, tree args)
12487 {
12488   tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12489   TREE_SIDE_EFFECTS (call) = 1;
12490   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12491   return call;
12492 }
12493
12494 /* Build an incomplete assignment expression. */
12495
12496 static tree
12497 build_assignment (int op, int op_location, tree lhs, tree rhs)
12498 {
12499   tree assignment;
12500   /* Build the corresponding binop if we deal with a Compound
12501      Assignment operator. Mark the binop sub-tree as part of a
12502      Compound Assignment expression */
12503   if (op != ASSIGN_TK)
12504     {
12505       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12506       COMPOUND_ASSIGN_P (rhs) = 1;
12507     }
12508   assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12509   TREE_SIDE_EFFECTS (assignment) = 1;
12510   EXPR_WFL_LINECOL (assignment) = op_location;
12511   return assignment;
12512 }
12513
12514 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12515    the buffer.  This is used only for string conversion.  */
12516 static char *
12517 string_convert_int_cst (tree node)
12518 {
12519   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12520   static char buffer[21];
12521
12522   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12523   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12524   char *p = buffer + sizeof (buffer);
12525   int neg = 0;
12526
12527   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12528                                   << (HOST_BITS_PER_WIDE_INT - 1));
12529
12530   *--p = '\0';
12531
12532   /* If negative, note the fact and negate the value.  */
12533   if ((hi & hibit))
12534     {
12535       lo = ~lo;
12536       hi = ~hi;
12537       if (++lo == 0)
12538         ++hi;
12539       neg = 1;
12540     }
12541
12542   /* Divide by 10 until there are no bits left.  */
12543   do
12544     {
12545       unsigned HOST_WIDE_INT acc = 0;
12546       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12547       unsigned int i;
12548
12549       /* Use long division to compute the result and the remainder.  */
12550       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12551         {
12552           /* Shift a bit into accumulator.  */
12553           acc <<= 1;
12554           if ((hi & hibit))
12555             acc |= 1;
12556
12557           /* Shift the value.  */
12558           hi <<= 1;
12559           if ((lo & hibit))
12560             hi |= 1;
12561           lo <<= 1;
12562
12563           /* Shift the correct bit into the result.  */
12564           outhi <<= 1;
12565           if ((outlo & hibit))
12566             outhi |= 1;
12567           outlo <<= 1;
12568           if (acc >= 10)
12569             {
12570               acc -= 10;
12571               outlo |= 1;
12572             }
12573         }
12574
12575       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12576       *--p = '\060' + acc;
12577
12578       hi = outhi;
12579       lo = outlo;
12580     }
12581   while (hi || lo);
12582
12583   if (neg)
12584     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12585
12586   return p;
12587 }
12588
12589 /* Print an INTEGER_CST node in a static buffer, and return the
12590    buffer.  This is used only for error handling.  */
12591 char *
12592 print_int_node (tree node)
12593 {
12594   static char buffer [80];
12595   if (TREE_CONSTANT_OVERFLOW (node))
12596     sprintf (buffer, "<overflow>");
12597
12598   if (TREE_INT_CST_HIGH (node) == 0)
12599     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12600              TREE_INT_CST_LOW (node));
12601   else if (TREE_INT_CST_HIGH (node) == -1
12602            && TREE_INT_CST_LOW (node) != 0)
12603     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12604              -TREE_INT_CST_LOW (node));
12605   else
12606     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12607              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12608
12609   return buffer;
12610 }
12611
12612 \f
12613 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12614    context.  */
12615
12616 /* 15.25 Assignment operators. */
12617
12618 static tree
12619 patch_assignment (tree node, tree wfl_op1)
12620 {
12621   tree rhs = TREE_OPERAND (node, 1);
12622   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12623   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12624   int error_found = 0;
12625   int lvalue_from_array = 0;
12626   int is_return = 0;
12627
12628   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12629
12630   /* Lhs can be a named variable */
12631   if (JDECL_P (lvalue))
12632     {
12633       lhs_type = TREE_TYPE (lvalue);
12634     }
12635   /* Or Lhs can be an array access. */
12636   else if (TREE_CODE (lvalue) == ARRAY_REF)
12637     {
12638       lhs_type = TREE_TYPE (lvalue);
12639       lvalue_from_array = 1;
12640     }
12641   /* Or a field access */
12642   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12643     lhs_type = TREE_TYPE (lvalue);
12644   /* Or a function return slot */
12645   else if (TREE_CODE (lvalue) == RESULT_DECL)
12646     {
12647       /* If the return type is an integral type, then we create the
12648          RESULT_DECL with a promoted type, but we need to do these
12649          checks against the unpromoted type to ensure type safety.  So
12650          here we look at the real type, not the type of the decl we
12651          are modifying.  */
12652       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12653       is_return = 1;
12654     }
12655   /* Otherwise, we might want to try to write into an optimized static
12656      final, this is an of a different nature, reported further on. */
12657   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12658            && resolve_expression_name (wfl_op1, &llvalue))
12659     {
12660       lhs_type = TREE_TYPE (lvalue);
12661     }
12662   else
12663     {
12664       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12665       error_found = 1;
12666     }
12667
12668   rhs_type = TREE_TYPE (rhs);
12669
12670   /* 5.1 Try the assignment conversion for builtin type. */
12671   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12672
12673   /* 5.2 If it failed, try a reference conversion */
12674   if (!new_rhs)
12675     new_rhs = try_reference_assignconv (lhs_type, rhs);
12676
12677   /* 15.25.2 If we have a compound assignment, convert RHS into the
12678      type of the LHS */
12679   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12680     new_rhs = convert (lhs_type, rhs);
12681
12682   /* Explicit cast required. This is an error */
12683   if (!new_rhs)
12684     {
12685       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12686       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12687       tree wfl;
12688       char operation [32];      /* Max size known */
12689
12690       /* If the assignment is part of a declaration, we use the WFL of
12691          the declared variable to point out the error and call it a
12692          declaration problem. If the assignment is a genuine =
12693          operator, we call is a operator `=' problem, otherwise we
12694          call it an assignment problem. In both of these last cases,
12695          we use the WFL of the operator to indicate the error. */
12696
12697       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12698         {
12699           wfl = wfl_op1;
12700           strcpy (operation, "declaration");
12701         }
12702       else
12703         {
12704           wfl = wfl_operator;
12705           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12706             strcpy (operation, "assignment");
12707           else if (is_return)
12708             strcpy (operation, "`return'");
12709           else
12710             strcpy (operation, "`='");
12711         }
12712
12713       if (!valid_cast_to_p (rhs_type, lhs_type))
12714         parse_error_context
12715           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12716            operation, t1, t2);
12717       else
12718         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12719                              operation, t1, t2);
12720       free (t1); free (t2);
12721       error_found = 1;
12722     }
12723
12724   if (error_found)
12725     return error_mark_node;
12726
12727   /* If we're processing a `return' statement, promote the actual type
12728      to the promoted type.  */
12729   if (is_return)
12730     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12731
12732   /* 10.10: Array Store Exception runtime check */
12733   if (!flag_emit_class_files
12734       && !flag_emit_xref
12735       && lvalue_from_array
12736       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12737     {
12738       tree array, store_check, base, index_expr;
12739
12740       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12741       new_rhs = save_expr (new_rhs);
12742
12743       /* Get the INDIRECT_REF. */
12744       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12745       /* Get the array pointer expr. */
12746       array = TREE_OPERAND (array, 0);
12747       store_check = build_java_arraystore_check (array, new_rhs);
12748
12749       index_expr = TREE_OPERAND (lvalue, 1);
12750
12751       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12752         {
12753           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12754              happen before the store check, so prepare to insert the store
12755              check within the second operand of the existing COMPOUND_EXPR. */
12756           base = index_expr;
12757         }
12758       else
12759         base = lvalue;
12760
12761       index_expr = TREE_OPERAND (base, 1);
12762       TREE_OPERAND (base, 1) = build (COMPOUND_EXPR, TREE_TYPE (index_expr),
12763                                       store_check, index_expr);
12764     }
12765
12766   /* Final locals can be used as case values in switch
12767      statement. Prepare them for this eventuality. */
12768   if (TREE_CODE (lvalue) == VAR_DECL
12769       && DECL_FINAL (lvalue)
12770       && TREE_CONSTANT (new_rhs)
12771       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12772       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12773       )
12774     {
12775       TREE_CONSTANT (lvalue) = 1;
12776       DECL_INITIAL (lvalue) = new_rhs;
12777     }
12778
12779   /* Copy the rhs if it's a reference.  */
12780   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12781     {
12782       switch (TREE_CODE (new_rhs))
12783         {
12784         case ARRAY_REF:
12785         case INDIRECT_REF:
12786         case COMPONENT_REF:
12787           /* Transform a = foo.bar
12788              into a = { int tmp; tmp = foo.bar; tmp; ).
12789              We need to ensure that if a read from memory fails
12790              because of a NullPointerException, a destination variable
12791              will remain unchanged.  An explicit temporary does what
12792              we need.
12793
12794              If flag_check_references is set, this is unnecessary
12795              because we'll check each reference before doing any
12796              reads.  If optimize is not set the result will never be
12797              written to a stack slot that contains the LHS.  */
12798           {
12799             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12800                                    TREE_TYPE (new_rhs));
12801             tree block = make_node (BLOCK);
12802             tree assignment
12803               = build (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12804             DECL_CONTEXT (tmp) = current_function_decl;
12805             TREE_TYPE (block) = TREE_TYPE (new_rhs);
12806             BLOCK_VARS (block) = tmp;
12807             BLOCK_EXPR_BODY (block)
12808               = build (COMPOUND_EXPR, TREE_TYPE (new_rhs), assignment, tmp);
12809             TREE_SIDE_EFFECTS (block) = 1;
12810             new_rhs = block;
12811           }
12812           break;
12813         default:
12814           break;
12815         }
12816     }
12817
12818   TREE_OPERAND (node, 0) = lvalue;
12819   TREE_OPERAND (node, 1) = new_rhs;
12820   TREE_TYPE (node) = lhs_type;
12821   return node;
12822 }
12823
12824 /* Check that type SOURCE can be cast into type DEST. If the cast
12825    can't occur at all, return NULL; otherwise, return a possibly
12826    modified rhs.  */
12827
12828 static tree
12829 try_reference_assignconv (tree lhs_type, tree rhs)
12830 {
12831   tree new_rhs = NULL_TREE;
12832   tree rhs_type = TREE_TYPE (rhs);
12833
12834   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12835     {
12836       /* `null' may be assigned to any reference type */
12837       if (rhs == null_pointer_node)
12838         new_rhs = null_pointer_node;
12839       /* Try the reference assignment conversion */
12840       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12841         new_rhs = rhs;
12842       /* This is a magic assignment that we process differently */
12843       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12844         new_rhs = rhs;
12845     }
12846   return new_rhs;
12847 }
12848
12849 /* Check that RHS can be converted into LHS_TYPE by the assignment
12850    conversion (5.2), for the cases of RHS being a builtin type. Return
12851    NULL_TREE if the conversion fails or if because RHS isn't of a
12852    builtin type. Return a converted RHS if the conversion is possible.  */
12853
12854 static tree
12855 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12856 {
12857   tree new_rhs = NULL_TREE;
12858   tree rhs_type = TREE_TYPE (rhs);
12859
12860   /* Handle boolean specially.  */
12861   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12862       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12863     {
12864       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12865           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12866         new_rhs = rhs;
12867     }
12868
12869   /* 5.1.1 Try Identity Conversion,
12870      5.1.2 Try Widening Primitive Conversion */
12871   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12872     new_rhs = convert (lhs_type, rhs);
12873
12874   /* Try a narrowing primitive conversion (5.1.3):
12875        - expression is a constant expression of type byte, short, char,
12876          or int, AND
12877        - variable is byte, short or char AND
12878        - The value of the expression is representable in the type of the
12879          variable */
12880   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12881             || rhs_type == char_type_node || rhs_type == int_type_node)
12882             && TREE_CONSTANT (rhs)
12883            && (lhs_type == byte_type_node || lhs_type == char_type_node
12884                || lhs_type == short_type_node))
12885     {
12886       if (int_fits_type_p (rhs, lhs_type))
12887         new_rhs = convert (lhs_type, rhs);
12888       else if (wfl_op1)         /* Might be called with a NULL */
12889         parse_warning_context
12890           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12891            print_int_node (rhs), lang_printable_name (lhs_type, 0));
12892       /* Reported a warning that will turn into an error further
12893          down, so we don't return */
12894     }
12895
12896   return new_rhs;
12897 }
12898
12899 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12900    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12901    0 is the conversion test fails.  This implements parts the method
12902    invocation conversion (5.3).  */
12903
12904 static int
12905 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
12906 {
12907   /* 5.1.1: This is the identity conversion part. */
12908   if (lhs_type == rhs_type)
12909     return 1;
12910
12911   /* Reject non primitive types and boolean conversions.  */
12912   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12913     return 0;
12914
12915   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12916      than a char can't be converted into a char. Short can't too, but
12917      the < test below takes care of that */
12918   if (lhs_type == char_type_node && rhs_type == byte_type_node)
12919     return 0;
12920
12921   /* Accept all promoted type here. Note, we can't use <= in the test
12922      below, because we still need to bounce out assignments of short
12923      to char and the likes */
12924   if (lhs_type == int_type_node
12925       && (rhs_type == promoted_byte_type_node
12926           || rhs_type == promoted_short_type_node
12927           || rhs_type == promoted_char_type_node
12928           || rhs_type == promoted_boolean_type_node))
12929     return 1;
12930
12931   /* From here, an integral is widened if its precision is smaller
12932      than the precision of the LHS or if the LHS is a floating point
12933      type, or the RHS is a float and the RHS a double. */
12934   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12935        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12936       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12937       || (rhs_type == float_type_node && lhs_type == double_type_node))
12938     return 1;
12939
12940   return 0;
12941 }
12942
12943 /* Check that something of SOURCE type can be assigned or cast to
12944    something of DEST type at runtime. Return 1 if the operation is
12945    valid, 0 otherwise. If CAST is set to 1, we're treating the case
12946    were SOURCE is cast into DEST, which borrows a lot of the
12947    assignment check. */
12948
12949 static int
12950 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
12951 {
12952   /* SOURCE or DEST might be null if not from a declared entity. */
12953   if (!source || !dest)
12954     return 0;
12955   if (JNULLP_TYPE_P (source))
12956     return 1;
12957   if (TREE_CODE (source) == POINTER_TYPE)
12958     source = TREE_TYPE (source);
12959   if (TREE_CODE (dest) == POINTER_TYPE)
12960     dest = TREE_TYPE (dest);
12961
12962   /* If source and dest are being compiled from bytecode, they may need to
12963      be loaded. */
12964   if (CLASS_P (source) && !CLASS_LOADED_P (source))
12965     {
12966       load_class (source, 1);
12967       safe_layout_class (source);
12968     }
12969   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
12970     {
12971       load_class (dest, 1);
12972       safe_layout_class (dest);
12973     }
12974
12975   /* Case where SOURCE is a class type */
12976   if (TYPE_CLASS_P (source))
12977     {
12978       if (TYPE_CLASS_P (dest))
12979         return  (source == dest
12980                  || inherits_from_p (source, dest)
12981                  || (cast && inherits_from_p (dest, source)));
12982       if (TYPE_INTERFACE_P (dest))
12983         {
12984           /* If doing a cast and SOURCE is final, the operation is
12985              always correct a compile time (because even if SOURCE
12986              does not implement DEST, a subclass of SOURCE might). */
12987           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12988             return 1;
12989           /* Otherwise, SOURCE must implement DEST */
12990           return interface_of_p (dest, source);
12991         }
12992       /* DEST is an array, cast permitted if SOURCE is of Object type */
12993       return (cast && source == object_type_node ? 1 : 0);
12994     }
12995   if (TYPE_INTERFACE_P (source))
12996     {
12997       if (TYPE_CLASS_P (dest))
12998         {
12999           /* If not casting, DEST must be the Object type */
13000           if (!cast)
13001             return dest == object_type_node;
13002           /* We're doing a cast. The cast is always valid is class
13003              DEST is not final, otherwise, DEST must implement SOURCE */
13004           else if (!CLASS_FINAL (TYPE_NAME (dest)))
13005             return 1;
13006           else
13007             return interface_of_p (source, dest);
13008         }
13009       if (TYPE_INTERFACE_P (dest))
13010         {
13011           /* If doing a cast, then if SOURCE and DEST contain method
13012              with the same signature but different return type, then
13013              this is a (compile time) error */
13014           if (cast)
13015             {
13016               tree method_source, method_dest;
13017               tree source_type;
13018               tree source_sig;
13019               tree source_name;
13020               for (method_source = TYPE_METHODS (source); method_source;
13021                    method_source = TREE_CHAIN (method_source))
13022                 {
13023                   source_sig =
13024                     build_java_argument_signature (TREE_TYPE (method_source));
13025                   source_type = TREE_TYPE (TREE_TYPE (method_source));
13026                   source_name = DECL_NAME (method_source);
13027                   for (method_dest = TYPE_METHODS (dest);
13028                        method_dest; method_dest = TREE_CHAIN (method_dest))
13029                     if (source_sig ==
13030                         build_java_argument_signature (TREE_TYPE (method_dest))
13031                         && source_name == DECL_NAME (method_dest)
13032                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
13033                       return 0;
13034                 }
13035               return 1;
13036             }
13037           else
13038             return source == dest || interface_of_p (dest, source);
13039         }
13040       else
13041         {
13042           /* Array */
13043           return (cast
13044                   && (DECL_NAME (TYPE_NAME (source))
13045                       == java_lang_cloneable_identifier_node
13046                       || (DECL_NAME (TYPE_NAME (source))
13047                           == java_io_serializable_identifier_node)));
13048         }
13049     }
13050   if (TYPE_ARRAY_P (source))
13051     {
13052       if (TYPE_CLASS_P (dest))
13053         return dest == object_type_node;
13054       /* Can't cast an array to an interface unless the interface is
13055          java.lang.Cloneable or java.io.Serializable.  */
13056       if (TYPE_INTERFACE_P (dest))
13057         return (DECL_NAME (TYPE_NAME (dest))
13058                 == java_lang_cloneable_identifier_node
13059                 || (DECL_NAME (TYPE_NAME (dest))
13060                     == java_io_serializable_identifier_node));
13061       else                      /* Arrays */
13062         {
13063           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13064           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13065
13066           /* In case of severe errors, they turn out null */
13067           if (!dest_element_type || !source_element_type)
13068             return 0;
13069           if (source_element_type == dest_element_type)
13070             return 1;
13071           return valid_ref_assignconv_cast_p (source_element_type,
13072                                               dest_element_type, cast);
13073         }
13074       return 0;
13075     }
13076   return 0;
13077 }
13078
13079 static int
13080 valid_cast_to_p (tree source, tree dest)
13081 {
13082   if (TREE_CODE (source) == POINTER_TYPE)
13083     source = TREE_TYPE (source);
13084   if (TREE_CODE (dest) == POINTER_TYPE)
13085     dest = TREE_TYPE (dest);
13086
13087   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13088     return valid_ref_assignconv_cast_p (source, dest, 1);
13089
13090   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13091     return 1;
13092
13093   else if (TREE_CODE (source) == BOOLEAN_TYPE
13094            && TREE_CODE (dest) == BOOLEAN_TYPE)
13095     return 1;
13096
13097   return 0;
13098 }
13099
13100 static tree
13101 do_unary_numeric_promotion (tree arg)
13102 {
13103   tree type = TREE_TYPE (arg);
13104   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13105       || TREE_CODE (type) == CHAR_TYPE)
13106     arg = convert (int_type_node, arg);
13107   return arg;
13108 }
13109
13110 /* Return a nonzero value if SOURCE can be converted into DEST using
13111    the method invocation conversion rule (5.3).  */
13112 static int
13113 valid_method_invocation_conversion_p (tree dest, tree source)
13114 {
13115   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13116            && valid_builtin_assignconv_identity_widening_p (dest, source))
13117           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13118               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13119               && valid_ref_assignconv_cast_p (source, dest, 0)));
13120 }
13121
13122 /* Build an incomplete binop expression. */
13123
13124 static tree
13125 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13126 {
13127   tree binop = build (op, NULL_TREE, op1, op2);
13128   TREE_SIDE_EFFECTS (binop) = 1;
13129   /* Store the location of the operator, for better error report. The
13130      string of the operator will be rebuild based on the OP value. */
13131   EXPR_WFL_LINECOL (binop) = op_location;
13132   return binop;
13133 }
13134
13135 /* Build the string of the operator retained by NODE. If NODE is part
13136    of a compound expression, add an '=' at the end of the string. This
13137    function is called when an error needs to be reported on an
13138    operator. The string is returned as a pointer to a static character
13139    buffer. */
13140
13141 static char *
13142 operator_string (tree node)
13143 {
13144 #define BUILD_OPERATOR_STRING(S)                                        \
13145   {                                                                     \
13146     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13147     return buffer;                                                      \
13148   }
13149
13150   static char buffer [10];
13151   switch (TREE_CODE (node))
13152     {
13153     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13154     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13155     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13156     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13157     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13158     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13159     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13160     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13161     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13162     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13163     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13164     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13165     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13166     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13167     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13168     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13169     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13170     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13171     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13172     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13173     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13174     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13175     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13176     case PREINCREMENT_EXPR:     /* Fall through */
13177     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13178     case PREDECREMENT_EXPR:     /* Fall through */
13179     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13180     default:
13181       internal_error ("unregistered operator %s",
13182                       tree_code_name [TREE_CODE (node)]);
13183     }
13184   return NULL;
13185 #undef BUILD_OPERATOR_STRING
13186 }
13187
13188 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13189
13190 static int
13191 java_decl_equiv (tree var_acc1, tree var_acc2)
13192 {
13193   if (JDECL_P (var_acc1))
13194     return (var_acc1 == var_acc2);
13195
13196   return (TREE_CODE (var_acc1) == COMPONENT_REF
13197           && TREE_CODE (var_acc2) == COMPONENT_REF
13198           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13199              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13200           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13201 }
13202
13203 /* Return a nonzero value if CODE is one of the operators that can be
13204    used in conjunction with the `=' operator in a compound assignment.  */
13205
13206 static int
13207 binop_compound_p (enum tree_code code)
13208 {
13209   int i;
13210   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13211     if (binop_lookup [i] == code)
13212       break;
13213
13214   return i < BINOP_COMPOUND_CANDIDATES;
13215 }
13216
13217 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13218
13219 static tree
13220 java_refold (tree t)
13221 {
13222   tree c, b, ns, decl;
13223
13224   if (TREE_CODE (t) != MODIFY_EXPR)
13225     return t;
13226
13227   c = TREE_OPERAND (t, 1);
13228   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13229          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13230          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13231     return t;
13232
13233   /* Now the left branch of the binary operator. */
13234   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13235   if (! (b && TREE_CODE (b) == NOP_EXPR
13236          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13237     return t;
13238
13239   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13240   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13241          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13242     return t;
13243
13244   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13245   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13246       /* It's got to be the an equivalent decl */
13247       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13248     {
13249       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13250       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13251       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13252       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13253       /* Change the right part of the BINOP_EXPR */
13254       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13255     }
13256
13257   return t;
13258 }
13259
13260 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13261    errors but we modify NODE so that it contains the type computed
13262    according to the expression, when it's fixed. Otherwise, we write
13263    error_mark_node as the type. It allows us to further the analysis
13264    of remaining nodes and detects more errors in certain cases.  */
13265
13266 static tree
13267 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13268 {
13269   tree op1 = TREE_OPERAND (node, 0);
13270   tree op2 = TREE_OPERAND (node, 1);
13271   tree op1_type = TREE_TYPE (op1);
13272   tree op2_type = TREE_TYPE (op2);
13273   tree prom_type = NULL_TREE, cn;
13274   enum tree_code code = TREE_CODE (node);
13275
13276   /* If 1, tell the routine that we have to return error_mark_node
13277      after checking for the initialization of the RHS */
13278   int error_found = 0;
13279
13280   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13281
13282   /* If either op<n>_type are NULL, this might be early signs of an
13283      error situation, unless it's too early to tell (in case we're
13284      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13285      correctly so the error can be later on reported accurately. */
13286   if (! (code == PLUS_EXPR || code == NE_EXPR
13287          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13288     {
13289       tree n;
13290       if (! op1_type)
13291         {
13292           n = java_complete_tree (op1);
13293           op1_type = TREE_TYPE (n);
13294         }
13295       if (! op2_type)
13296         {
13297           n = java_complete_tree (op2);
13298           op2_type = TREE_TYPE (n);
13299         }
13300     }
13301
13302   switch (code)
13303     {
13304     /* 15.16 Multiplicative operators */
13305     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13306     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13307     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13308     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13309       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13310         {
13311           if (!JNUMERIC_TYPE_P (op1_type))
13312             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13313           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13314             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13315           TREE_TYPE (node) = error_mark_node;
13316           error_found = 1;
13317           break;
13318         }
13319       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13320
13321       /* Detect integral division by zero */
13322       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13323           && TREE_CODE (prom_type) == INTEGER_TYPE
13324           && (op2 == integer_zero_node || op2 == long_zero_node ||
13325               (TREE_CODE (op2) == INTEGER_CST &&
13326                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13327         {
13328           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13329           TREE_CONSTANT (node) = 0;
13330         }
13331
13332       /* Change the division operator if necessary */
13333       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13334         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13335
13336       /* Before divisions as is disappear, try to simplify and bail if
13337          applicable, otherwise we won't perform even simple
13338          simplifications like (1-1)/3. We can't do that with floating
13339          point number, folds can't handle them at this stage. */
13340       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13341           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13342         {
13343           TREE_TYPE (node) = prom_type;
13344           node = fold (node);
13345           if (TREE_CODE (node) != code)
13346             return node;
13347         }
13348
13349       if (TREE_CODE (prom_type) == INTEGER_TYPE
13350           && flag_use_divide_subroutine
13351           && ! flag_emit_class_files
13352           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13353         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13354
13355       /* This one is more complicated. FLOATs are processed by a
13356          function call to soft_fmod. Duplicate the value of the
13357          COMPOUND_ASSIGN_P flag. */
13358       if (code == TRUNC_MOD_EXPR)
13359         {
13360           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13361           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13362           TREE_SIDE_EFFECTS (mod)
13363             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13364           return mod;
13365         }
13366       break;
13367
13368     /* 15.17 Additive Operators */
13369     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13370
13371       /* Operation is valid if either one argument is a string
13372          constant, a String object or a StringBuffer crafted for the
13373          purpose of the a previous usage of the String concatenation
13374          operator */
13375
13376       if (TREE_CODE (op1) == STRING_CST
13377           || TREE_CODE (op2) == STRING_CST
13378           || JSTRING_TYPE_P (op1_type)
13379           || JSTRING_TYPE_P (op2_type)
13380           || IS_CRAFTED_STRING_BUFFER_P (op1)
13381           || IS_CRAFTED_STRING_BUFFER_P (op2))
13382         return build_string_concatenation (op1, op2);
13383
13384     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13385                                    Numeric Types */
13386       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13387         {
13388           if (!JNUMERIC_TYPE_P (op1_type))
13389             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13390           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13391             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13392           TREE_TYPE (node) = error_mark_node;
13393           error_found = 1;
13394           break;
13395         }
13396       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13397       break;
13398
13399     /* 15.18 Shift Operators */
13400     case LSHIFT_EXPR:
13401     case RSHIFT_EXPR:
13402     case URSHIFT_EXPR:
13403       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13404         {
13405           if (!JINTEGRAL_TYPE_P (op1_type))
13406             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13407           else
13408             {
13409               if (JNUMERIC_TYPE_P (op2_type))
13410                 parse_error_context (wfl_operator,
13411                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13412                                      operator_string (node),
13413                                      lang_printable_name (op2_type, 0));
13414               else
13415                 parse_error_context (wfl_operator,
13416                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13417                                      operator_string (node),
13418                                      lang_printable_name (op2_type, 0));
13419             }
13420           TREE_TYPE (node) = error_mark_node;
13421           error_found = 1;
13422           break;
13423         }
13424
13425       /* Unary numeric promotion (5.6.1) is performed on each operand
13426          separately */
13427       op1 = do_unary_numeric_promotion (op1);
13428       op2 = do_unary_numeric_promotion (op2);
13429
13430       /* If the right hand side is of type `long', first cast it to
13431          `int'.  */
13432       if (TREE_TYPE (op2) == long_type_node)
13433         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13434
13435       /* The type of the shift expression is the type of the promoted
13436          type of the left-hand operand */
13437       prom_type = TREE_TYPE (op1);
13438
13439       /* Shift int only up to 0x1f and long up to 0x3f */
13440       if (prom_type == int_type_node)
13441         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13442                            build_int_2 (0x1f, 0)));
13443       else
13444         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13445                            build_int_2 (0x3f, 0)));
13446
13447       /* The >>> operator is a >> operating on unsigned quantities */
13448       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13449         {
13450           tree to_return;
13451           tree utype = java_unsigned_type (prom_type);
13452           op1 = convert (utype, op1);
13453           TREE_SET_CODE (node, RSHIFT_EXPR);
13454           TREE_OPERAND (node, 0) = op1;
13455           TREE_OPERAND (node, 1) = op2;
13456           TREE_TYPE (node) = utype;
13457           to_return = convert (prom_type, node);
13458           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13459           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13460           TREE_SIDE_EFFECTS (to_return)
13461             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13462           return to_return;
13463         }
13464       break;
13465
13466       /* 15.19.1 Type Comparison Operator instanceof */
13467     case INSTANCEOF_EXPR:
13468
13469       TREE_TYPE (node) = boolean_type_node;
13470
13471       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13472       if ((cn = patch_string (op1)))
13473         {
13474           op1 = cn;
13475           op1_type = TREE_TYPE (op1);
13476         }
13477       if (op1_type == NULL_TREE)
13478         abort ();
13479
13480       if (!(op2_type = resolve_type_during_patch (op2)))
13481         return error_mark_node;
13482
13483       /* The first operand must be a reference type or the null type */
13484       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13485         error_found = 1;        /* Error reported further below */
13486
13487       /* The second operand must be a reference type */
13488       if (!JREFERENCE_TYPE_P (op2_type))
13489         {
13490           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13491           parse_error_context
13492             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13493              lang_printable_name (op2_type, 0));
13494           error_found = 1;
13495         }
13496
13497       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13498         {
13499           /* If the first operand is null, the result is always false */
13500           if (op1 == null_pointer_node)
13501             return boolean_false_node;
13502           else if (flag_emit_class_files)
13503             {
13504               TREE_OPERAND (node, 1) = op2_type;
13505               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13506               return node;
13507             }
13508           /* Otherwise we have to invoke instance of to figure it out */
13509           else
13510             return build_instanceof (op1, op2_type);
13511         }
13512       /* There is no way the expression operand can be an instance of
13513          the type operand. This is a compile time error. */
13514       else
13515         {
13516           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13517           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13518           parse_error_context
13519             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13520              t1, lang_printable_name (op2_type, 0));
13521           free (t1);
13522           error_found = 1;
13523         }
13524
13525       break;
13526
13527       /* 15.21 Bitwise and Logical Operators */
13528     case BIT_AND_EXPR:
13529     case BIT_XOR_EXPR:
13530     case BIT_IOR_EXPR:
13531       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13532         /* Binary numeric promotion is performed on both operand and the
13533            expression retain that type */
13534         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13535
13536       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13537                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13538         /* The type of the bitwise operator expression is BOOLEAN */
13539         prom_type = boolean_type_node;
13540       else
13541         {
13542           if (!JINTEGRAL_TYPE_P (op1_type))
13543             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13544           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13545             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13546           TREE_TYPE (node) = error_mark_node;
13547           error_found = 1;
13548           /* Insert a break here if adding thing before the switch's
13549              break for this case */
13550         }
13551       break;
13552
13553       /* 15.22 Conditional-And Operator */
13554     case TRUTH_ANDIF_EXPR:
13555       /* 15.23 Conditional-Or Operator */
13556     case TRUTH_ORIF_EXPR:
13557       /* Operands must be of BOOLEAN type */
13558       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13559           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13560         {
13561           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13562             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13563           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13564             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13565           TREE_TYPE (node) = boolean_type_node;
13566           error_found = 1;
13567           break;
13568         }
13569       else if (integer_zerop (op1))
13570         {
13571           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13572         }
13573       else if (integer_onep (op1))
13574         {
13575           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13576         }
13577       /* The type of the conditional operators is BOOLEAN */
13578       prom_type = boolean_type_node;
13579       break;
13580
13581       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13582     case LT_EXPR:
13583     case GT_EXPR:
13584     case LE_EXPR:
13585     case GE_EXPR:
13586       /* The type of each of the operands must be a primitive numeric
13587          type */
13588       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13589         {
13590           if (!JNUMERIC_TYPE_P (op1_type))
13591             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13592           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13593             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13594           TREE_TYPE (node) = boolean_type_node;
13595           error_found = 1;
13596           break;
13597         }
13598       /* Binary numeric promotion is performed on the operands */
13599       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13600       /* The type of the relation expression is always BOOLEAN */
13601       prom_type = boolean_type_node;
13602       break;
13603
13604       /* 15.20 Equality Operator */
13605     case EQ_EXPR:
13606     case NE_EXPR:
13607       /* It's time for us to patch the strings. */
13608       if ((cn = patch_string (op1)))
13609        {
13610          op1 = cn;
13611          op1_type = TREE_TYPE (op1);
13612        }
13613       if ((cn = patch_string (op2)))
13614        {
13615          op2 = cn;
13616          op2_type = TREE_TYPE (op2);
13617        }
13618
13619       /* 15.20.1 Numerical Equality Operators == and != */
13620       /* Binary numeric promotion is performed on the operands */
13621       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13622         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13623
13624       /* 15.20.2 Boolean Equality Operators == and != */
13625       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13626           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13627         ;                       /* Nothing to do here */
13628
13629       /* 15.20.3 Reference Equality Operators == and != */
13630       /* Types have to be either references or the null type. If
13631          they're references, it must be possible to convert either
13632          type to the other by casting conversion. */
13633       else if (op1 == null_pointer_node || op2 == null_pointer_node
13634                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13635                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13636                        || valid_ref_assignconv_cast_p (op2_type,
13637                                                        op1_type, 1))))
13638         ;                       /* Nothing to do here */
13639
13640       /* Else we have an error figure what can't be converted into
13641          what and report the error */
13642       else
13643         {
13644           char *t1;
13645           t1 = xstrdup (lang_printable_name (op1_type, 0));
13646           parse_error_context
13647             (wfl_operator,
13648              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13649              operator_string (node), t1,
13650              lang_printable_name (op2_type, 0));
13651           free (t1);
13652           TREE_TYPE (node) = boolean_type_node;
13653           error_found = 1;
13654           break;
13655         }
13656       prom_type = boolean_type_node;
13657       break;
13658     default:
13659       abort ();
13660     }
13661
13662   if (error_found)
13663     return error_mark_node;
13664
13665   TREE_OPERAND (node, 0) = op1;
13666   TREE_OPERAND (node, 1) = op2;
13667   TREE_TYPE (node) = prom_type;
13668   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13669
13670   if (flag_emit_xref)
13671     return node;
13672
13673   /* fold does not respect side-effect order as required for Java but not C.
13674    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13675    * bytecode.
13676    */
13677   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13678       : ! TREE_SIDE_EFFECTS (node))
13679     node = fold (node);
13680   return node;
13681 }
13682
13683 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13684    zero value, the value of CSTE comes after the valude of STRING */
13685
13686 static tree
13687 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13688 {
13689   const char *old = TREE_STRING_POINTER (cste);
13690   int old_len = TREE_STRING_LENGTH (cste);
13691   int len = old_len + string_len;
13692   char *new = alloca (len+1);
13693
13694   if (after)
13695     {
13696       memcpy (new, string, string_len);
13697       memcpy (&new [string_len], old, old_len);
13698     }
13699   else
13700     {
13701       memcpy (new, old, old_len);
13702       memcpy (&new [old_len], string, string_len);
13703     }
13704   new [len] = '\0';
13705   return build_string (len, new);
13706 }
13707
13708 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13709    new STRING_CST on success, NULL_TREE on failure.  */
13710
13711 static tree
13712 merge_string_cste (tree op1, tree op2, int after)
13713 {
13714   /* Handle two string constants right away.  */
13715   if (TREE_CODE (op2) == STRING_CST)
13716     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13717                                  TREE_STRING_LENGTH (op2), after);
13718
13719   /* Reasonable integer constant can be treated right away.  */
13720   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13721     {
13722       static const char *const boolean_true = "true";
13723       static const char *const boolean_false = "false";
13724       static const char *const null_pointer = "null";
13725       char ch[4];
13726       const char *string;
13727
13728       if (op2 == boolean_true_node)
13729         string = boolean_true;
13730       else if (op2 == boolean_false_node)
13731         string = boolean_false;
13732       else if (op2 == null_pointer_node
13733                || (integer_zerop (op2)
13734                    && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
13735         /* FIXME: null is not a compile-time constant, so it is only safe to
13736            merge if the overall expression is non-constant. However, this
13737            code always merges without checking the overall expression.  */
13738         string = null_pointer;
13739       else if (TREE_TYPE (op2) == char_type_node)
13740         {
13741           /* Convert the character into UTF-8.  */
13742           unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13743           unsigned char *p = (unsigned char *) ch;
13744           if (0x01 <= c && c <= 0x7f)
13745             *p++ = (unsigned char) c;
13746           else if (c < 0x7ff)
13747             {
13748               *p++ = (unsigned char) (c >> 6 | 0xc0);
13749               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13750             }
13751           else
13752             {
13753               *p++ = (unsigned char) (c >> 12 | 0xe0);
13754               *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13755               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13756             }
13757           *p = '\0';
13758
13759           string = ch;
13760         }
13761       else
13762         string = string_convert_int_cst (op2);
13763
13764       return do_merge_string_cste (op1, string, strlen (string), after);
13765     }
13766   return NULL_TREE;
13767 }
13768
13769 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13770    has to be a STRING_CST and the other part must be a STRING_CST or a
13771    INTEGRAL constant. Return a new STRING_CST if the operation
13772    succeed, NULL_TREE otherwise.
13773
13774    If the case we want to optimize for space, we might want to return
13775    NULL_TREE for each invocation of this routine. FIXME */
13776
13777 static tree
13778 string_constant_concatenation (tree op1, tree op2)
13779 {
13780   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13781     {
13782       tree string, rest;
13783       int invert;
13784
13785       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13786       rest   = (string == op1 ? op2 : op1);
13787       invert = (string == op1 ? 0 : 1 );
13788
13789       /* Walk REST, only if it looks reasonable */
13790       if (TREE_CODE (rest) != STRING_CST
13791           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13792           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13793           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13794         {
13795           rest = java_complete_tree (rest);
13796           if (rest == error_mark_node)
13797             return error_mark_node;
13798           rest = fold (rest);
13799         }
13800       return merge_string_cste (string, rest, invert);
13801     }
13802   return NULL_TREE;
13803 }
13804
13805 /* Implement the `+' operator. Does static optimization if possible,
13806    otherwise create (if necessary) and append elements to a
13807    StringBuffer. The StringBuffer will be carried around until it is
13808    used for a function call or an assignment. Then toString() will be
13809    called on it to turn it into a String object. */
13810
13811 static tree
13812 build_string_concatenation (tree op1, tree op2)
13813 {
13814   tree result;
13815   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13816
13817   if (flag_emit_xref)
13818     return build (PLUS_EXPR, string_type_node, op1, op2);
13819
13820   /* Try to do some static optimization */
13821   if ((result = string_constant_concatenation (op1, op2)))
13822     return result;
13823
13824   /* Discard empty strings on either side of the expression */
13825   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13826     {
13827       op1 = op2;
13828       op2 = NULL_TREE;
13829     }
13830   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13831     op2 = NULL_TREE;
13832
13833   /* If operands are string constant, turn then into object references */
13834   if (TREE_CODE (op1) == STRING_CST)
13835     op1 = patch_string_cst (op1);
13836   if (op2 && TREE_CODE (op2) == STRING_CST)
13837     op2 = patch_string_cst (op2);
13838
13839   /* If either one of the constant is null and the other non null
13840      operand is a String constant, return it. */
13841   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13842     return op1;
13843
13844   /* If OP1 isn't already a StringBuffer, create and
13845      initialize a new one */
13846   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13847     {
13848       /* Two solutions here:
13849          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13850          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13851       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13852         op1 = BUILD_STRING_BUFFER (op1);
13853       else
13854         {
13855           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13856           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13857         }
13858     }
13859
13860   if (op2)
13861     {
13862       /* OP1 is no longer the last node holding a crafted StringBuffer */
13863       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13864       /* Create a node for `{new...,xxx}.append (op2)' */
13865       if (op2)
13866         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13867     }
13868
13869   /* Mark the last node holding a crafted StringBuffer */
13870   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13871
13872   TREE_SIDE_EFFECTS (op1) = side_effects;
13873   return op1;
13874 }
13875
13876 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13877    StringBuffer. If no string were found to be patched, return
13878    NULL. */
13879
13880 static tree
13881 patch_string (tree node)
13882 {
13883   if (node == error_mark_node)
13884     return error_mark_node;
13885   if (TREE_CODE (node) == STRING_CST)
13886     return patch_string_cst (node);
13887   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13888     {
13889       int saved = ctxp->explicit_constructor_p;
13890       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13891       tree ret;
13892       /* Temporary disable forbid the use of `this'. */
13893       ctxp->explicit_constructor_p = 0;
13894       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13895       /* String concatenation arguments must be evaluated in order too. */
13896       ret = force_evaluation_order (ret);
13897       /* Restore it at its previous value */
13898       ctxp->explicit_constructor_p = saved;
13899       return ret;
13900     }
13901   return NULL_TREE;
13902 }
13903
13904 /* Build the internal representation of a string constant.  */
13905
13906 static tree
13907 patch_string_cst (tree node)
13908 {
13909   int location;
13910   if (! flag_emit_class_files)
13911     {
13912       node = get_identifier (TREE_STRING_POINTER (node));
13913       location = alloc_name_constant (CONSTANT_String, node);
13914       node = build_ref_from_constant_pool (location);
13915     }
13916   TREE_TYPE (node) = string_ptr_type_node;
13917   TREE_CONSTANT (node) = 1;
13918   return node;
13919 }
13920
13921 /* Build an incomplete unary operator expression. */
13922
13923 static tree
13924 build_unaryop (int op_token, int op_location, tree op1)
13925 {
13926   enum tree_code op;
13927   tree unaryop;
13928   switch (op_token)
13929     {
13930     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13931     case MINUS_TK: op = NEGATE_EXPR; break;
13932     case NEG_TK: op = TRUTH_NOT_EXPR; break;
13933     case NOT_TK: op = BIT_NOT_EXPR; break;
13934     default: abort ();
13935     }
13936
13937   unaryop = build1 (op, NULL_TREE, op1);
13938   TREE_SIDE_EFFECTS (unaryop) = 1;
13939   /* Store the location of the operator, for better error report. The
13940      string of the operator will be rebuild based on the OP value. */
13941   EXPR_WFL_LINECOL (unaryop) = op_location;
13942   return unaryop;
13943 }
13944
13945 /* Special case for the ++/-- operators, since they require an extra
13946    argument to build, which is set to NULL and patched
13947    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
13948
13949 static tree
13950 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
13951 {
13952   static const enum tree_code lookup [2][2] =
13953     {
13954       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
13955       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
13956     };
13957   tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
13958                      NULL_TREE, op1, NULL_TREE);
13959   TREE_SIDE_EFFECTS (node) = 1;
13960   /* Store the location of the operator, for better error report. The
13961      string of the operator will be rebuild based on the OP value. */
13962   EXPR_WFL_LINECOL (node) = op_location;
13963   return node;
13964 }
13965
13966 /* Build an incomplete cast operator, based on the use of the
13967    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13968    set. java_complete_tree is trained to walk a CONVERT_EXPR even
13969    though its type is already set.  */
13970
13971 static tree
13972 build_cast (int location, tree type, tree exp)
13973 {
13974   tree node = build1 (CONVERT_EXPR, type, exp);
13975   EXPR_WFL_LINECOL (node) = location;
13976   return node;
13977 }
13978
13979 /* Build an incomplete class reference operator.  */
13980 static tree
13981 build_incomplete_class_ref (int location, tree class_name)
13982 {
13983   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13984   tree class_decl = GET_CPC ();
13985   tree this_class = TREE_TYPE (class_decl);
13986
13987   /* Generate the synthetic static method `class$'.  (Previously we
13988      deferred this, causing different method tables to be emitted
13989      for native code and bytecode.)  */
13990   if (!TYPE_DOT_CLASS (this_class)
13991       && !JPRIMITIVE_TYPE_P (class_name)
13992       && !(TREE_CODE (class_name) == VOID_TYPE))
13993     {
13994       tree target_class;
13995
13996       if (CLASS_INTERFACE (TYPE_NAME (this_class)))
13997         {
13998           /* For interfaces, adding a static 'class$' method directly
13999              is illegal.  So create an inner class to contain the new
14000              method.  Empirically this matches the behavior of javac.  */
14001           tree t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
14002           tree inner = create_anonymous_class (0, t);
14003           target_class = TREE_TYPE (inner);
14004           end_class_declaration (1);
14005         }
14006       else
14007         {
14008           /* For inner classes, add a 'class$' method to their outermost
14009              context, creating it if necessary.  */
14010           while (INNER_CLASS_DECL_P (class_decl))
14011             class_decl = DECL_CONTEXT (class_decl);
14012           target_class = TREE_TYPE (class_decl);
14013         }
14014
14015       if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
14016         build_dot_class_method (target_class);
14017
14018       if (this_class != target_class)
14019         TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
14020     }
14021
14022   EXPR_WFL_LINECOL (node) = location;
14023   return node;
14024 }
14025
14026 /* Complete an incomplete class reference operator.  */
14027 static tree
14028 patch_incomplete_class_ref (tree node)
14029 {
14030   tree type = TREE_OPERAND (node, 0);
14031   tree ref_type;
14032
14033   if (!(ref_type = resolve_type_during_patch (type)))
14034     return error_mark_node;
14035
14036   /* If we're not emitting class files and we know ref_type is a
14037      compiled class, build a direct reference.  */
14038   if ((! flag_emit_class_files && is_compiled_class (ref_type))
14039       || JPRIMITIVE_TYPE_P (ref_type)
14040       || TREE_CODE (ref_type) == VOID_TYPE)
14041     {
14042       tree dot = build_class_ref (ref_type);
14043       /* A class referenced by `foo.class' is initialized.  */
14044       if (!flag_emit_class_files)
14045        dot = build_class_init (ref_type, dot);
14046       return java_complete_tree (dot);
14047     }
14048
14049   /* If we're emitting class files and we have to deal with non
14050      primitive types, we invoke the synthetic static method `class$'.  */
14051   ref_type = build_dot_class_method_invocation (current_class, ref_type);
14052   return java_complete_tree (ref_type);
14053 }
14054
14055 /* 15.14 Unary operators. We return error_mark_node in case of error,
14056    but preserve the type of NODE if the type is fixed.  */
14057
14058 static tree
14059 patch_unaryop (tree node, tree wfl_op)
14060 {
14061   tree op = TREE_OPERAND (node, 0);
14062   tree op_type = TREE_TYPE (op);
14063   tree prom_type = NULL_TREE, value, decl;
14064   int outer_field_flag = 0;
14065   int code = TREE_CODE (node);
14066   int error_found = 0;
14067
14068   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14069
14070   switch (code)
14071     {
14072       /* 15.13.2 Postfix Increment Operator ++ */
14073     case POSTINCREMENT_EXPR:
14074       /* 15.13.3 Postfix Increment Operator -- */
14075     case POSTDECREMENT_EXPR:
14076       /* 15.14.1 Prefix Increment Operator ++ */
14077     case PREINCREMENT_EXPR:
14078       /* 15.14.2 Prefix Decrement Operator -- */
14079     case PREDECREMENT_EXPR:
14080       op = decl = strip_out_static_field_access_decl (op);
14081       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14082       /* We might be trying to change an outer field accessed using
14083          access method. */
14084       if (outer_field_flag)
14085         {
14086           /* Retrieve the decl of the field we're trying to access. We
14087              do that by first retrieving the function we would call to
14088              access the field. It has been already verified that this
14089              field isn't final */
14090           if (flag_emit_class_files)
14091             decl = TREE_OPERAND (op, 0);
14092           else
14093             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14094           decl = DECL_FUNCTION_ACCESS_DECL (decl);
14095         }
14096       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14097       else if (!JDECL_P (decl)
14098           && TREE_CODE (decl) != COMPONENT_REF
14099           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14100           && TREE_CODE (decl) != INDIRECT_REF
14101           && !(TREE_CODE (decl) == COMPOUND_EXPR
14102                && TREE_OPERAND (decl, 1)
14103                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14104         {
14105           TREE_TYPE (node) = error_mark_node;
14106           error_found = 1;
14107         }
14108
14109       /* From now on, we know that op if a variable and that it has a
14110          valid wfl. We use wfl_op to locate errors related to the
14111          ++/-- operand. */
14112       if (!JNUMERIC_TYPE_P (op_type))
14113         {
14114           parse_error_context
14115             (wfl_op, "Invalid argument type `%s' to `%s'",
14116              lang_printable_name (op_type, 0), operator_string (node));
14117           TREE_TYPE (node) = error_mark_node;
14118           error_found = 1;
14119         }
14120       else
14121         {
14122           /* Before the addition, binary numeric promotion is performed on
14123              both operands, if really necessary */
14124           if (JINTEGRAL_TYPE_P (op_type))
14125             {
14126               value = build_int_2 (1, 0);
14127               TREE_TYPE (value) = TREE_TYPE (node) = op_type;
14128             }
14129           else
14130             {
14131               value = build_int_2 (1, 0);
14132               TREE_TYPE (node) =
14133                 binary_numeric_promotion (op_type,
14134                                           TREE_TYPE (value), &op, &value);
14135             }
14136
14137           /* We remember we might be accessing an outer field */
14138           if (outer_field_flag)
14139             {
14140               /* We re-generate an access to the field */
14141               value = build (PLUS_EXPR, TREE_TYPE (op),
14142                              build_outer_field_access (wfl_op, decl), value);
14143
14144               /* And we patch the original access$() into a write
14145                  with plus_op as a rhs */
14146               return outer_field_access_fix (node, op, value);
14147             }
14148
14149           /* And write back into the node. */
14150           TREE_OPERAND (node, 0) = op;
14151           TREE_OPERAND (node, 1) = value;
14152           /* Convert the overall back into its original type, if
14153              necessary, and return */
14154           if (JINTEGRAL_TYPE_P (op_type))
14155             return fold (node);
14156           else
14157             return fold (convert (op_type, node));
14158         }
14159       break;
14160
14161       /* 15.14.3 Unary Plus Operator + */
14162     case UNARY_PLUS_EXPR:
14163       /* 15.14.4 Unary Minus Operator - */
14164     case NEGATE_EXPR:
14165       if (!JNUMERIC_TYPE_P (op_type))
14166         {
14167           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14168           TREE_TYPE (node) = error_mark_node;
14169           error_found = 1;
14170         }
14171       /* Unary numeric promotion is performed on operand */
14172       else
14173         {
14174           op = do_unary_numeric_promotion (op);
14175           prom_type = TREE_TYPE (op);
14176           if (code == UNARY_PLUS_EXPR)
14177             return fold (op);
14178         }
14179       break;
14180
14181       /* 15.14.5 Bitwise Complement Operator ~ */
14182     case BIT_NOT_EXPR:
14183       if (!JINTEGRAL_TYPE_P (op_type))
14184         {
14185           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14186           TREE_TYPE (node) = error_mark_node;
14187           error_found = 1;
14188         }
14189       else
14190         {
14191           op = do_unary_numeric_promotion (op);
14192           prom_type = TREE_TYPE (op);
14193         }
14194       break;
14195
14196       /* 15.14.6 Logical Complement Operator ! */
14197     case TRUTH_NOT_EXPR:
14198       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14199         {
14200           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14201           /* But the type is known. We will report an error if further
14202              attempt of a assignment is made with this rhs */
14203           TREE_TYPE (node) = boolean_type_node;
14204           error_found = 1;
14205         }
14206       else
14207         prom_type = boolean_type_node;
14208       break;
14209
14210       /* 15.15 Cast Expression */
14211     case CONVERT_EXPR:
14212       value = patch_cast (node, wfl_operator);
14213       if (value == error_mark_node)
14214         {
14215           /* If this cast is part of an assignment, we tell the code
14216              that deals with it not to complain about a mismatch,
14217              because things have been cast, anyways */
14218           TREE_TYPE (node) = error_mark_node;
14219           error_found = 1;
14220         }
14221       else
14222         {
14223           value = fold (value);
14224           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14225           return value;
14226         }
14227       break;
14228     }
14229
14230   if (error_found)
14231     return error_mark_node;
14232
14233   /* There are cases where node has been replaced by something else
14234      and we don't end up returning here: UNARY_PLUS_EXPR,
14235      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14236   TREE_OPERAND (node, 0) = fold (op);
14237   TREE_TYPE (node) = prom_type;
14238   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14239   return fold (node);
14240 }
14241
14242 /* Generic type resolution that sometimes takes place during node
14243    patching. Returned the resolved type or generate an error
14244    message. Return the resolved type or NULL_TREE.  */
14245
14246 static tree
14247 resolve_type_during_patch (tree type)
14248 {
14249   if (unresolved_type_p (type, NULL))
14250     {
14251       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14252       if (!type_decl)
14253         {
14254           parse_error_context (type,
14255                                "Class `%s' not found in type declaration",
14256                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14257           return NULL_TREE;
14258         }
14259
14260       check_deprecation (type, type_decl);
14261
14262       return TREE_TYPE (type_decl);
14263     }
14264   return type;
14265 }
14266
14267 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14268    found. Otherwise NODE or something meant to replace it is returned.  */
14269
14270 static tree
14271 patch_cast (tree node, tree wfl_op)
14272 {
14273   tree op = TREE_OPERAND (node, 0);
14274   tree cast_type = TREE_TYPE (node);
14275   tree patched, op_type;
14276   char *t1;
14277
14278   /* Some string patching might be necessary at this stage */
14279   if ((patched = patch_string (op)))
14280     TREE_OPERAND (node, 0) = op = patched;
14281   op_type = TREE_TYPE (op);
14282
14283   /* First resolve OP_TYPE if unresolved */
14284   if (!(cast_type = resolve_type_during_patch (cast_type)))
14285     return error_mark_node;
14286
14287   /* Check on cast that are proven correct at compile time */
14288   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14289     {
14290       /* Same type */
14291       if (cast_type == op_type)
14292         return node;
14293
14294       /* A narrowing conversion from a floating-point number to an
14295          integral type requires special handling (5.1.3).  */
14296       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14297         if (cast_type != long_type_node)
14298           op = convert (integer_type_node, op);
14299
14300       /* Try widening/narrowing conversion.  Potentially, things need
14301          to be worked out in gcc so we implement the extreme cases
14302          correctly.  fold_convert() needs to be fixed.  */
14303       return convert (cast_type, op);
14304     }
14305
14306   /* It's also valid to cast a boolean into a boolean */
14307   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14308     return node;
14309
14310   /* null can be casted to references */
14311   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14312     return build_null_of_type (cast_type);
14313
14314   /* The remaining legal casts involve conversion between reference
14315      types. Check for their compile time correctness. */
14316   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14317       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14318     {
14319       TREE_TYPE (node) = promote_type (cast_type);
14320       /* Now, the case can be determined correct at compile time if
14321          OP_TYPE can be converted into CAST_TYPE by assignment
14322          conversion (5.2) */
14323
14324       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14325         {
14326           TREE_SET_CODE (node, NOP_EXPR);
14327           return node;
14328         }
14329
14330       if (flag_emit_class_files)
14331         {
14332           TREE_SET_CODE (node, CONVERT_EXPR);
14333           return node;
14334         }
14335
14336       /* The cast requires a run-time check */
14337       return build (CALL_EXPR, promote_type (cast_type),
14338                     build_address_of (soft_checkcast_node),
14339                     tree_cons (NULL_TREE, build_class_ref (cast_type),
14340                                build_tree_list (NULL_TREE, op)),
14341                     NULL_TREE);
14342     }
14343
14344   /* Any other casts are proven incorrect at compile time */
14345   t1 = xstrdup (lang_printable_name (op_type, 0));
14346   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14347                        t1, lang_printable_name (cast_type, 0));
14348   free (t1);
14349   return error_mark_node;
14350 }
14351
14352 /* Build a null constant and give it the type TYPE.  */
14353
14354 static tree
14355 build_null_of_type (tree type)
14356 {
14357   tree node = build_int_2 (0, 0);
14358   TREE_TYPE (node) = promote_type (type);
14359   return node;
14360 }
14361
14362 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14363    a list of indices. */
14364 static tree
14365 build_array_ref (int location, tree array, tree index)
14366 {
14367   tree node = build (ARRAY_REF, NULL_TREE, array, index);
14368   EXPR_WFL_LINECOL (node) = location;
14369   return node;
14370 }
14371
14372 /* 15.12 Array Access Expression */
14373
14374 static tree
14375 patch_array_ref (tree node)
14376 {
14377   tree array = TREE_OPERAND (node, 0);
14378   tree array_type  = TREE_TYPE (array);
14379   tree index = TREE_OPERAND (node, 1);
14380   tree index_type = TREE_TYPE (index);
14381   int error_found = 0;
14382
14383   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14384
14385   if (TREE_CODE (array_type) == POINTER_TYPE)
14386     array_type = TREE_TYPE (array_type);
14387
14388   /* The array reference must be an array */
14389   if (!TYPE_ARRAY_P (array_type))
14390     {
14391       parse_error_context
14392         (wfl_operator,
14393          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14394          lang_printable_name (array_type, 0));
14395       TREE_TYPE (node) = error_mark_node;
14396       error_found = 1;
14397     }
14398
14399   /* The array index undergoes unary numeric promotion. The promoted
14400      type must be int */
14401   index = do_unary_numeric_promotion (index);
14402   if (TREE_TYPE (index) != int_type_node)
14403     {
14404       if (valid_cast_to_p (index_type, int_type_node))
14405         parse_error_context (wfl_operator,
14406    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14407                              lang_printable_name (index_type, 0));
14408       else
14409         parse_error_context (wfl_operator,
14410           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14411                              lang_printable_name (index_type, 0));
14412       TREE_TYPE (node) = error_mark_node;
14413       error_found = 1;
14414     }
14415
14416   if (error_found)
14417     return error_mark_node;
14418
14419   array_type = TYPE_ARRAY_ELEMENT (array_type);
14420
14421   if (flag_emit_class_files || flag_emit_xref)
14422     {
14423       TREE_OPERAND (node, 0) = array;
14424       TREE_OPERAND (node, 1) = index;
14425     }
14426   else
14427     node = build_java_arrayaccess (array, array_type, index);
14428   TREE_TYPE (node) = array_type;
14429   return node;
14430 }
14431
14432 /* 15.9 Array Creation Expressions */
14433
14434 static tree
14435 build_newarray_node (tree type, tree dims, int extra_dims)
14436 {
14437   tree node =
14438     build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
14439            build_int_2 (extra_dims, 0));
14440   return node;
14441 }
14442
14443 static tree
14444 patch_newarray (tree node)
14445 {
14446   tree type = TREE_OPERAND (node, 0);
14447   tree dims = TREE_OPERAND (node, 1);
14448   tree cdim, array_type;
14449   int error_found = 0;
14450   int ndims = 0;
14451   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14452
14453   /* Dimension types are verified. It's better for the types to be
14454      verified in order. */
14455   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14456     {
14457       int dim_error = 0;
14458       tree dim = TREE_VALUE (cdim);
14459
14460       /* Dim might have been saved during its evaluation */
14461       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14462
14463       /* The type of each specified dimension must be an integral type. */
14464       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14465         dim_error = 1;
14466
14467       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14468          promoted type must be int. */
14469       else
14470         {
14471           dim = do_unary_numeric_promotion (dim);
14472           if (TREE_TYPE (dim) != int_type_node)
14473             dim_error = 1;
14474         }
14475
14476       /* Report errors on types here */
14477       if (dim_error)
14478         {
14479           parse_error_context
14480             (TREE_PURPOSE (cdim),
14481              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14482              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14483               "Explicit cast needed to" : "Can't"),
14484              lang_printable_name (TREE_TYPE (dim), 0));
14485           error_found = 1;
14486         }
14487
14488       TREE_PURPOSE (cdim) = NULL_TREE;
14489     }
14490
14491   /* Resolve array base type if unresolved */
14492   if (!(type = resolve_type_during_patch (type)))
14493     error_found = 1;
14494
14495   if (error_found)
14496     {
14497       /* We don't want further evaluation of this bogus array creation
14498          operation */
14499       TREE_TYPE (node) = error_mark_node;
14500       return error_mark_node;
14501     }
14502
14503   /* Set array_type to the actual (promoted) array type of the result. */
14504   if (TREE_CODE (type) == RECORD_TYPE)
14505     type = build_pointer_type (type);
14506   while (--xdims >= 0)
14507     {
14508       type = promote_type (build_java_array_type (type, -1));
14509     }
14510   dims = nreverse (dims);
14511   array_type = type;
14512   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14513     {
14514       type = array_type;
14515       array_type
14516         = build_java_array_type (type,
14517                                  TREE_CODE (cdim) == INTEGER_CST
14518                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14519                                  : -1);
14520       array_type = promote_type (array_type);
14521     }
14522   dims = nreverse (dims);
14523
14524   /* The node is transformed into a function call. Things are done
14525      differently according to the number of dimensions. If the number
14526      of dimension is equal to 1, then the nature of the base type
14527      (primitive or not) matters. */
14528   if (ndims == 1)
14529     return build_new_array (type, TREE_VALUE (dims));
14530
14531   /* Can't reuse what's already written in expr.c because it uses the
14532      JVM stack representation. Provide a build_multianewarray. FIXME */
14533   return build (CALL_EXPR, array_type,
14534                 build_address_of (soft_multianewarray_node),
14535                 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
14536                            tree_cons (NULL_TREE,
14537                                       build_int_2 (ndims, 0), dims )),
14538                 NULL_TREE);
14539 }
14540
14541 /* 10.6 Array initializer.  */
14542
14543 /* Build a wfl for array element that don't have one, so we can
14544    pin-point errors.  */
14545
14546 static tree
14547 maybe_build_array_element_wfl (tree node)
14548 {
14549   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14550     return build_expr_wfl (NULL_TREE, ctxp->filename,
14551                            ctxp->elc.line, ctxp->elc.prev_col);
14552   else
14553     return NULL_TREE;
14554 }
14555
14556 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14557    identification of initialized arrays easier to detect during walk
14558    and expansion.  */
14559
14560 static tree
14561 build_new_array_init (int location, tree values)
14562 {
14563   tree constructor = build_constructor (NULL_TREE, values);
14564   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14565   EXPR_WFL_LINECOL (to_return) = location;
14566   return to_return;
14567 }
14568
14569 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14570    occurred.  Otherwise return NODE after having set its type
14571    appropriately.  */
14572
14573 static tree
14574 patch_new_array_init (tree type, tree node)
14575 {
14576   int error_seen = 0;
14577   tree current, element_type;
14578   HOST_WIDE_INT length;
14579   int all_constant = 1;
14580   tree init = TREE_OPERAND (node, 0);
14581
14582   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14583     {
14584       parse_error_context (node,
14585                            "Invalid array initializer for non-array type `%s'",
14586                            lang_printable_name (type, 1));
14587       return error_mark_node;
14588     }
14589   type = TREE_TYPE (type);
14590   element_type = TYPE_ARRAY_ELEMENT (type);
14591
14592   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14593
14594   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14595        current;  length++, current = TREE_CHAIN (current))
14596     {
14597       tree elt = TREE_VALUE (current);
14598       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14599         {
14600           error_seen |= array_constructor_check_entry (element_type, current);
14601           elt = TREE_VALUE (current);
14602           /* When compiling to native code, STRING_CST is converted to
14603              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14604           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14605             all_constant = 0;
14606         }
14607       else
14608         {
14609           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14610           TREE_PURPOSE (current) = NULL_TREE;
14611           all_constant = 0;
14612         }
14613       if (elt && TREE_CODE (elt) == TREE_LIST
14614           && TREE_VALUE (elt) == error_mark_node)
14615         error_seen = 1;
14616     }
14617
14618   if (error_seen)
14619     return error_mark_node;
14620
14621   /* Create a new type. We can't reuse the one we have here by
14622      patching its dimension because it originally is of dimension -1
14623      hence reused by gcc. This would prevent triangular arrays. */
14624   type = build_java_array_type (element_type, length);
14625   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14626   TREE_TYPE (node) = promote_type (type);
14627   TREE_CONSTANT (init) = all_constant;
14628   TREE_CONSTANT (node) = all_constant;
14629   return node;
14630 }
14631
14632 /* Verify that one entry of the initializer element list can be
14633    assigned to the array base type. Report 1 if an error occurred, 0
14634    otherwise.  */
14635
14636 static int
14637 array_constructor_check_entry (tree type, tree entry)
14638 {
14639   char *array_type_string = NULL;       /* For error reports */
14640   tree value, type_value, new_value, wfl_value, patched;
14641   int error_seen = 0;
14642
14643   new_value = NULL_TREE;
14644   wfl_value = TREE_VALUE (entry);
14645
14646   value = java_complete_tree (TREE_VALUE (entry));
14647   /* patch_string return error_mark_node if arg is error_mark_node */
14648   if ((patched = patch_string (value)))
14649     value = patched;
14650   if (value == error_mark_node)
14651     return 1;
14652
14653   type_value = TREE_TYPE (value);
14654
14655   /* At anytime, try_builtin_assignconv can report a warning on
14656      constant overflow during narrowing. */
14657   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14658   new_value = try_builtin_assignconv (wfl_operator, type, value);
14659   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14660     type_value = promote_type (type);
14661
14662   /* Check and report errors */
14663   if (!new_value)
14664     {
14665       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14666                    "Can't" : "Explicit cast needed to");
14667       if (!array_type_string)
14668         array_type_string = xstrdup (lang_printable_name (type, 1));
14669       parse_error_context
14670         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14671          msg, lang_printable_name (type_value, 1), array_type_string);
14672       error_seen = 1;
14673     }
14674
14675   if (new_value)
14676     TREE_VALUE (entry) = new_value;
14677
14678   if (array_type_string)
14679     free (array_type_string);
14680
14681   TREE_PURPOSE (entry) = NULL_TREE;
14682   return error_seen;
14683 }
14684
14685 static tree
14686 build_this (int location)
14687 {
14688   tree node = build_wfl_node (this_identifier_node);
14689   TREE_SET_CODE (node, THIS_EXPR);
14690   EXPR_WFL_LINECOL (node) = location;
14691   return node;
14692 }
14693
14694 /* 14.15 The return statement. It builds a modify expression that
14695    assigns the returned value to the RESULT_DECL that hold the value
14696    to be returned. */
14697
14698 static tree
14699 build_return (int location, tree op)
14700 {
14701   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14702   EXPR_WFL_LINECOL (node) = location;
14703   node = build_debugable_stmt (location, node);
14704   return node;
14705 }
14706
14707 static tree
14708 patch_return (tree node)
14709 {
14710   tree return_exp = TREE_OPERAND (node, 0);
14711   tree meth = current_function_decl;
14712   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14713   int error_found = 0;
14714
14715   TREE_TYPE (node) = error_mark_node;
14716   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14717
14718   /* It's invalid to have a return value within a function that is
14719      declared with the keyword void or that is a constructor */
14720   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14721     error_found = 1;
14722
14723   /* It's invalid to use a return statement in a static block */
14724   if (DECL_CLINIT_P (current_function_decl))
14725     error_found = 1;
14726
14727   /* It's invalid to have a no return value within a function that
14728      isn't declared with the keyword `void' */
14729   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14730     error_found = 2;
14731
14732   if (DECL_INSTINIT_P (current_function_decl))
14733     error_found = 1;
14734
14735   if (error_found)
14736     {
14737       if (DECL_INSTINIT_P (current_function_decl))
14738         parse_error_context (wfl_operator,
14739                              "`return' inside instance initializer");
14740
14741       else if (DECL_CLINIT_P (current_function_decl))
14742         parse_error_context (wfl_operator,
14743                              "`return' inside static initializer");
14744
14745       else if (!DECL_CONSTRUCTOR_P (meth))
14746         {
14747           char *t = xstrdup (lang_printable_name (mtype, 0));
14748           parse_error_context (wfl_operator,
14749                                "`return' with%s value from `%s %s'",
14750                                (error_found == 1 ? "" : "out"),
14751                                t, lang_printable_name (meth, 0));
14752           free (t);
14753         }
14754       else
14755         parse_error_context (wfl_operator,
14756                              "`return' with value from constructor `%s'",
14757                              lang_printable_name (meth, 0));
14758       return error_mark_node;
14759     }
14760
14761   /* If we have a return_exp, build a modify expression and expand
14762      it. Note: at that point, the assignment is declared valid, but we
14763      may want to carry some more hacks */
14764   if (return_exp)
14765     {
14766       tree exp = java_complete_tree (return_exp);
14767       tree modify, patched;
14768
14769       if ((patched = patch_string (exp)))
14770         exp = patched;
14771
14772       modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14773       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14774       modify = java_complete_tree (modify);
14775
14776       if (modify != error_mark_node)
14777         {
14778           TREE_SIDE_EFFECTS (modify) = 1;
14779           TREE_OPERAND (node, 0) = modify;
14780         }
14781       else
14782         return error_mark_node;
14783     }
14784   TREE_TYPE (node) = void_type_node;
14785   TREE_SIDE_EFFECTS (node) = 1;
14786   return node;
14787 }
14788
14789 /* 14.8 The if Statement */
14790
14791 static tree
14792 build_if_else_statement (int location, tree expression, tree if_body,
14793                          tree else_body)
14794 {
14795   tree node;
14796   if (!else_body)
14797     else_body = empty_stmt_node;
14798   node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14799   EXPR_WFL_LINECOL (node) = location;
14800   node = build_debugable_stmt (location, node);
14801   return node;
14802 }
14803
14804 static tree
14805 patch_if_else_statement (tree node)
14806 {
14807   tree expression = TREE_OPERAND (node, 0);
14808   int can_complete_normally
14809     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14810        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14811
14812   TREE_TYPE (node) = error_mark_node;
14813   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14814
14815   /* The type of expression must be boolean */
14816   if (TREE_TYPE (expression) != boolean_type_node
14817       && TREE_TYPE (expression) != promoted_boolean_type_node)
14818     {
14819       parse_error_context
14820         (wfl_operator,
14821          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14822          lang_printable_name (TREE_TYPE (expression), 0));
14823       return error_mark_node;
14824     }
14825
14826   if (TREE_CODE (expression) == INTEGER_CST)
14827     {
14828       if (integer_zerop (expression))
14829         node = TREE_OPERAND (node, 2);
14830       else
14831         node = TREE_OPERAND (node, 1);
14832       if (CAN_COMPLETE_NORMALLY (node) != can_complete_normally)
14833         {
14834           node = build (COMPOUND_EXPR, void_type_node, node, empty_stmt_node);
14835           CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14836         }
14837       return node;
14838     }
14839   TREE_TYPE (node) = void_type_node;
14840   TREE_SIDE_EFFECTS (node) = 1;
14841   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14842   return node;
14843 }
14844
14845 /* 14.6 Labeled Statements */
14846
14847 /* Action taken when a labeled statement is parsed. a new
14848    LABELED_BLOCK_EXPR is created. No statement is attached to the
14849    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14850
14851 static tree
14852 build_labeled_block (int location, tree label)
14853 {
14854   tree label_name ;
14855   tree label_decl, node;
14856   if (label == NULL_TREE || label == continue_identifier_node)
14857     label_name = label;
14858   else
14859     {
14860       label_name = merge_qualified_name (label_id, label);
14861       /* Issue an error if we try to reuse a label that was previously
14862          declared */
14863       if (IDENTIFIER_LOCAL_VALUE (label_name))
14864         {
14865           EXPR_WFL_LINECOL (wfl_operator) = location;
14866           parse_error_context (wfl_operator,
14867             "Declaration of `%s' shadows a previous label declaration",
14868                                IDENTIFIER_POINTER (label));
14869           EXPR_WFL_LINECOL (wfl_operator) =
14870             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14871           parse_error_context (wfl_operator,
14872             "This is the location of the previous declaration of label `%s'",
14873                                IDENTIFIER_POINTER (label));
14874           java_error_count--;
14875         }
14876     }
14877
14878   label_decl = create_label_decl (label_name);
14879   node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14880   EXPR_WFL_LINECOL (node) = location;
14881   TREE_SIDE_EFFECTS (node) = 1;
14882   return node;
14883 }
14884
14885 /* A labeled statement LBE is attached a statement.  */
14886
14887 static tree
14888 finish_labeled_statement (tree lbe, /* Labeled block expr */
14889                           tree statement)
14890 {
14891   /* In anyways, tie the loop to its statement */
14892   LABELED_BLOCK_BODY (lbe) = statement;
14893   pop_labeled_block ();
14894   POP_LABELED_BLOCK ();
14895   return lbe;
14896 }
14897
14898 /* 14.10, 14.11, 14.12 Loop Statements */
14899
14900 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14901    list. */
14902
14903 static tree
14904 build_new_loop (tree loop_body)
14905 {
14906   tree loop =  build (LOOP_EXPR, NULL_TREE, loop_body);
14907   TREE_SIDE_EFFECTS (loop) = 1;
14908   PUSH_LOOP (loop);
14909   return loop;
14910 }
14911
14912 /* Create a loop body according to the following structure:
14913      COMPOUND_EXPR
14914        COMPOUND_EXPR            (loop main body)
14915          EXIT_EXPR              (this order is for while/for loops.
14916          LABELED_BLOCK_EXPR      the order is reversed for do loops)
14917            LABEL_DECL           (a continue occurring here branches at the
14918            BODY                  end of this labeled block)
14919        INCREMENT                (if any)
14920
14921   REVERSED, if nonzero, tells that the loop condition expr comes
14922   after the body, like in the do-while loop.
14923
14924   To obtain a loop, the loop body structure described above is
14925   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14926
14927    LABELED_BLOCK_EXPR
14928      LABEL_DECL                   (use this label to exit the loop)
14929      LOOP_EXPR
14930        <structure described above> */
14931
14932 static tree
14933 build_loop_body (int location, tree condition, int reversed)
14934 {
14935   tree first, second, body;
14936
14937   condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14938   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14939   condition = build_debugable_stmt (location, condition);
14940   TREE_SIDE_EFFECTS (condition) = 1;
14941
14942   body = build_labeled_block (0, continue_identifier_node);
14943   first = (reversed ? body : condition);
14944   second = (reversed ? condition : body);
14945   return
14946     build (COMPOUND_EXPR, NULL_TREE,
14947            build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
14948 }
14949
14950 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14951    their order) on the current loop. Unlink the current loop from the
14952    loop list.  */
14953
14954 static tree
14955 finish_loop_body (int location, tree condition, tree body, int reversed)
14956 {
14957   tree to_return = ctxp->current_loop;
14958   tree loop_body = LOOP_EXPR_BODY (to_return);
14959   if (condition)
14960     {
14961       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14962       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14963          The real EXIT_EXPR is one operand further. */
14964       EXPR_WFL_LINECOL (cnode) = location;
14965       /* This one is for accurate error reports */
14966       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14967       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14968     }
14969   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14970   POP_LOOP ();
14971   return to_return;
14972 }
14973
14974 /* Tailored version of finish_loop_body for FOR loops, when FOR
14975    loops feature the condition part */
14976
14977 static tree
14978 finish_for_loop (int location, tree condition, tree update, tree body)
14979 {
14980   /* Put the condition and the loop body in place */
14981   tree loop = finish_loop_body (location, condition, body, 0);
14982   /* LOOP is the current loop which has been now popped of the loop
14983      stack.  Mark the update block as reachable and install it.  We do
14984      this because the (current interpretation of the) JLS requires
14985      that the update expression be considered reachable even if the
14986      for loop's body doesn't complete normally.  */
14987   if (update != NULL_TREE && update != empty_stmt_node)
14988     {
14989       tree up2 = update;
14990       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
14991         up2 = EXPR_WFL_NODE (up2);
14992       /* It is possible for the update expression to be an
14993          EXPR_WFL_NODE wrapping nothing.  */
14994       if (up2 != NULL_TREE && up2 != empty_stmt_node)
14995         {
14996           /* Try to detect constraint violations.  These would be
14997              programming errors somewhere.  */
14998           if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
14999               || TREE_CODE (up2) == LOOP_EXPR)
15000             abort ();
15001           SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
15002         }
15003     }
15004   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
15005   return loop;
15006 }
15007
15008 /* Try to find the loop a block might be related to. This comprises
15009    the case where the LOOP_EXPR is found as the second operand of a
15010    COMPOUND_EXPR, because the loop happens to have an initialization
15011    part, then expressed as the first operand of the COMPOUND_EXPR. If
15012    the search finds something, 1 is returned. Otherwise, 0 is
15013    returned. The search is assumed to start from a
15014    LABELED_BLOCK_EXPR's block.  */
15015
15016 static tree
15017 search_loop (tree statement)
15018 {
15019   if (TREE_CODE (statement) == LOOP_EXPR)
15020     return statement;
15021
15022   if (TREE_CODE (statement) == BLOCK)
15023     statement = BLOCK_SUBBLOCKS (statement);
15024   else
15025     return NULL_TREE;
15026
15027   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15028     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15029       statement = TREE_OPERAND (statement, 1);
15030
15031   return (TREE_CODE (statement) == LOOP_EXPR
15032           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
15033 }
15034
15035 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15036    returned otherwise.  */
15037
15038 static int
15039 labeled_block_contains_loop_p (tree block, tree loop)
15040 {
15041   if (!block)
15042     return 0;
15043
15044   if (LABELED_BLOCK_BODY (block) == loop)
15045     return 1;
15046
15047   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
15048     return 1;
15049
15050   return 0;
15051 }
15052
15053 /* If the loop isn't surrounded by a labeled statement, create one and
15054    insert LOOP as its body.  */
15055
15056 static tree
15057 patch_loop_statement (tree loop)
15058 {
15059   tree loop_label;
15060
15061   TREE_TYPE (loop) = void_type_node;
15062   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
15063     return loop;
15064
15065   loop_label = build_labeled_block (0, NULL_TREE);
15066   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15067      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15068   LABELED_BLOCK_BODY (loop_label) = loop;
15069   PUSH_LABELED_BLOCK (loop_label);
15070   return loop_label;
15071 }
15072
15073 /* 14.13, 14.14: break and continue Statements */
15074
15075 /* Build a break or a continue statement. a null NAME indicates an
15076    unlabeled break/continue statement.  */
15077
15078 static tree
15079 build_bc_statement (int location, int is_break, tree name)
15080 {
15081   tree break_continue, label_block_expr = NULL_TREE;
15082
15083   if (name)
15084     {
15085       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15086             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15087         /* Null means that we don't have a target for this named
15088            break/continue. In this case, we make the target to be the
15089            label name, so that the error can be reported accurately in
15090            patch_bc_statement. */
15091         label_block_expr = EXPR_WFL_NODE (name);
15092     }
15093   /* Unlabeled break/continue will be handled during the
15094      break/continue patch operation */
15095   break_continue
15096     = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
15097
15098   IS_BREAK_STMT_P (break_continue) = is_break;
15099   TREE_SIDE_EFFECTS (break_continue) = 1;
15100   EXPR_WFL_LINECOL (break_continue) = location;
15101   break_continue = build_debugable_stmt (location, break_continue);
15102   return break_continue;
15103 }
15104
15105 /* Verification of a break/continue statement. */
15106
15107 static tree
15108 patch_bc_statement (tree node)
15109 {
15110   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15111   tree labeled_block = ctxp->current_labeled_block;
15112   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15113
15114   /* Having an identifier here means that the target is unknown. */
15115   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15116     {
15117       parse_error_context (wfl_operator, "No label definition found for `%s'",
15118                            IDENTIFIER_POINTER (bc_label));
15119       return error_mark_node;
15120     }
15121   if (! IS_BREAK_STMT_P (node))
15122     {
15123       /* It's a continue statement. */
15124       for (;; labeled_block = TREE_CHAIN (labeled_block))
15125         {
15126           if (labeled_block == NULL_TREE)
15127             {
15128               if (bc_label == NULL_TREE)
15129                 parse_error_context (wfl_operator,
15130                                      "`continue' must be in loop");
15131               else
15132                 parse_error_context
15133                   (wfl_operator, "continue label `%s' does not name a loop",
15134                    IDENTIFIER_POINTER (bc_label));
15135               return error_mark_node;
15136             }
15137           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15138                == continue_identifier_node)
15139               && (bc_label == NULL_TREE
15140                   || TREE_CHAIN (labeled_block) == bc_label))
15141             {
15142               bc_label = labeled_block;
15143               break;
15144             }
15145         }
15146     }
15147   else if (!bc_label)
15148     {
15149       for (;; labeled_block = TREE_CHAIN (labeled_block))
15150         {
15151           if (labeled_block == NULL_TREE)
15152             {
15153               parse_error_context (wfl_operator,
15154                                      "`break' must be in loop or switch");
15155               return error_mark_node;
15156             }
15157           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15158           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15159               || search_loop (target_stmt))
15160             {
15161               bc_label = labeled_block;
15162               break;
15163             }
15164         }
15165     }
15166
15167   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15168   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15169
15170   /* Our break/continue don't return values. */
15171   TREE_TYPE (node) = void_type_node;
15172   /* Encapsulate the break within a compound statement so that it's
15173      expanded all the times by expand_expr (and not clobbered
15174      sometimes, like after a if statement) */
15175   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15176   TREE_SIDE_EFFECTS (node) = 1;
15177   return node;
15178 }
15179
15180 /* Process the exit expression belonging to a loop. Its type must be
15181    boolean.  */
15182
15183 static tree
15184 patch_exit_expr (tree node)
15185 {
15186   tree expression = TREE_OPERAND (node, 0);
15187   TREE_TYPE (node) = error_mark_node;
15188   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15189
15190   /* The type of expression must be boolean */
15191   if (TREE_TYPE (expression) != boolean_type_node)
15192     {
15193       parse_error_context
15194         (wfl_operator,
15195     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15196          lang_printable_name (TREE_TYPE (expression), 0));
15197       return error_mark_node;
15198     }
15199   /* Now we know things are allright, invert the condition, fold and
15200      return */
15201   TREE_OPERAND (node, 0) =
15202     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15203
15204   if (! integer_zerop (TREE_OPERAND (node, 0))
15205       && ctxp->current_loop != NULL_TREE
15206       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15207     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15208   if (! integer_onep (TREE_OPERAND (node, 0)))
15209     CAN_COMPLETE_NORMALLY (node) = 1;
15210
15211
15212   TREE_TYPE (node) = void_type_node;
15213   return node;
15214 }
15215
15216 /* 14.9 Switch statement */
15217
15218 static tree
15219 patch_switch_statement (tree node)
15220 {
15221   tree se = TREE_OPERAND (node, 0), se_type;
15222   tree save, iter;
15223
15224   /* Complete the switch expression */
15225   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15226   se_type = TREE_TYPE (se);
15227   /* The type of the switch expression must be char, byte, short or
15228      int */
15229   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15230     {
15231       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15232       parse_error_context (wfl_operator,
15233           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15234                            lang_printable_name (se_type, 0));
15235       /* This is what java_complete_tree will check */
15236       TREE_OPERAND (node, 0) = error_mark_node;
15237       return error_mark_node;
15238     }
15239
15240   /* Save and restore the outer case label list.  */
15241   save = case_label_list;
15242   case_label_list = NULL_TREE;
15243
15244   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15245
15246   /* See if we've found a duplicate label.  We can't leave this until
15247      code generation, because in `--syntax-only' and `-C' modes we
15248      don't do ordinary code generation.  */
15249   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15250     {
15251       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15252       tree subiter;
15253       for (subiter = TREE_CHAIN (iter);
15254            subiter != NULL_TREE;
15255            subiter = TREE_CHAIN (subiter))
15256         {
15257           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15258           if (val == subval)
15259             {
15260               EXPR_WFL_LINECOL (wfl_operator)
15261                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15262               /* The case_label_list is in reverse order, so print the
15263                  outer label first.  */
15264               parse_error_context (wfl_operator, "duplicate case label: `"
15265                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15266               EXPR_WFL_LINECOL (wfl_operator)
15267                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15268               parse_error_context (wfl_operator, "original label is here");
15269
15270               break;
15271             }
15272         }
15273     }
15274
15275   case_label_list = save;
15276
15277   /* Ready to return */
15278   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15279     {
15280       TREE_TYPE (node) = error_mark_node;
15281       return error_mark_node;
15282     }
15283   TREE_TYPE (node) = void_type_node;
15284   TREE_SIDE_EFFECTS (node) = 1;
15285   CAN_COMPLETE_NORMALLY (node)
15286     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15287       || ! SWITCH_HAS_DEFAULT (node);
15288   return node;
15289 }
15290
15291 /* Assertions.  */
15292
15293 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15294    might be NULL_TREE.  */
15295 static tree
15296 build_assertion (int location, tree condition, tree value)
15297 {
15298   tree node;
15299   tree klass = GET_CPC ();
15300
15301   if (! CLASS_USES_ASSERTIONS (klass))
15302     {
15303       tree field, classdollar, id, call;
15304       tree class_type = TREE_TYPE (klass);
15305
15306       field = add_field (class_type,
15307                          get_identifier ("$assertionsDisabled"),
15308                          boolean_type_node,
15309                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15310       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15311       FIELD_SYNTHETIC (field) = 1;
15312
15313       classdollar = build_incomplete_class_ref (location, class_type);
15314
15315       /* Call CLASS.desiredAssertionStatus().  */
15316       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15317       call = build (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15318       call = make_qualified_primary (classdollar, call, location);
15319       TREE_SIDE_EFFECTS (call) = 1;
15320
15321       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15322          seem odd, but we do it to generate code identical to that of
15323          the JDK.  */
15324       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15325       TREE_SIDE_EFFECTS (call) = 1;
15326       DECL_INITIAL (field) = call;
15327
15328       /* Record the initializer in the initializer statement list.  */
15329       call = build (MODIFY_EXPR, NULL_TREE, field, call);
15330       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15331       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15332       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15333
15334       CLASS_USES_ASSERTIONS (klass) = 1;
15335     }
15336
15337   if (value != NULL_TREE)
15338     value = tree_cons (NULL_TREE, value, NULL_TREE);
15339
15340   node = build_wfl_node (get_identifier ("java"));
15341   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15342                               location);
15343   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15344                               location);
15345
15346   node = build (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15347   TREE_SIDE_EFFECTS (node) = 1;
15348   /* It is too early to use BUILD_THROW.  */
15349   node = build1 (THROW_EXPR, NULL_TREE, node);
15350   TREE_SIDE_EFFECTS (node) = 1;
15351
15352   /* We invert the condition; if we just put NODE as the `else' part
15353      then we generate weird-looking bytecode.  */
15354   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15355   /* Check $assertionsDisabled.  */
15356   condition
15357     = build (TRUTH_ANDIF_EXPR, NULL_TREE,
15358              build1 (TRUTH_NOT_EXPR, NULL_TREE,
15359                      build_wfl_node (get_identifier ("$assertionsDisabled"))),
15360              condition);
15361   node = build_if_else_statement (location, condition, node, NULL_TREE);
15362   return node;
15363 }
15364
15365 /* 14.18 The try/catch statements */
15366
15367 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15368    catches TYPE and executes CATCH_STMTS.  */
15369
15370 static tree
15371 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15372                             tree catch_stmts)
15373 {
15374   tree try_block, catch_clause_param, catch_block, catch;
15375
15376   /* First build a try block */
15377   try_block = build_expr_block (try_stmts, NULL_TREE);
15378
15379   /* Build a catch block: we need a catch clause parameter */
15380   if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15381     {
15382       tree catch_type = obtain_incomplete_type (type_or_name);
15383       jdep *dep;
15384       catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15385       register_incomplete_type (JDEP_VARIABLE, type_or_name,
15386                                 catch_clause_param, catch_type);
15387       dep = CLASSD_LAST (ctxp->classd_list);
15388       JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15389     }
15390   else
15391     catch_clause_param = build_decl (VAR_DECL, wpv_id,
15392                                      build_pointer_type (type_or_name));
15393
15394   /* And a block */
15395   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15396
15397   /* Initialize the variable and store in the block */
15398   catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15399                  build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15400   add_stmt_to_block (catch_block, NULL_TREE, catch);
15401
15402   /* Add the catch statements */
15403   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15404
15405   /* Now we can build a CATCH_EXPR */
15406   catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
15407
15408   return build_try_statement (location, try_block, catch_block);
15409 }
15410
15411 static tree
15412 build_try_statement (int location, tree try_block, tree catches)
15413 {
15414   tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
15415   EXPR_WFL_LINECOL (node) = location;
15416   return node;
15417 }
15418
15419 static tree
15420 build_try_finally_statement (int location, tree try_block, tree finally)
15421 {
15422   tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15423   EXPR_WFL_LINECOL (node) = location;
15424   return node;
15425 }
15426
15427 static tree
15428 patch_try_statement (tree node)
15429 {
15430   int error_found = 0;
15431   tree try = TREE_OPERAND (node, 0);
15432   /* Exception handlers are considered in left to right order */
15433   tree catch = nreverse (TREE_OPERAND (node, 1));
15434   tree current, caught_type_list = NULL_TREE;
15435
15436   /* Check catch clauses, if any. Every time we find an error, we try
15437      to process the next catch clause. We process the catch clause before
15438      the try block so that when processing the try block we can check thrown
15439      exceptions againts the caught type list. */
15440   for (current = catch; current; current = TREE_CHAIN (current))
15441     {
15442       tree carg_decl, carg_type;
15443       tree sub_current, catch_block, catch_clause;
15444       int unreachable;
15445
15446       /* At this point, the structure of the catch clause is
15447            CATCH_EXPR           (catch node)
15448              BLOCK              (with the decl of the parameter)
15449                COMPOUND_EXPR
15450                  MODIFY_EXPR   (assignment of the catch parameter)
15451                  BLOCK          (catch clause block)
15452        */
15453       catch_clause = TREE_OPERAND (current, 0);
15454       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15455       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15456
15457       /* Catch clauses can't have more than one parameter declared,
15458          but it's already enforced by the grammar. Make sure that the
15459          only parameter of the clause statement in of class Throwable
15460          or a subclass of Throwable, but that was done earlier. The
15461          catch clause parameter type has also been resolved. */
15462
15463       /* Just make sure that the catch clause parameter type inherits
15464          from java.lang.Throwable */
15465       if (!inherits_from_p (carg_type, throwable_type_node))
15466         {
15467           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15468           parse_error_context (wfl_operator,
15469                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15470                                lang_printable_name (carg_type, 0));
15471           error_found = 1;
15472           continue;
15473         }
15474
15475       /* Partial check for unreachable catch statement: The catch
15476          clause is reachable iff is no earlier catch block A in
15477          the try statement such that the type of the catch
15478          clause's parameter is the same as or a subclass of the
15479          type of A's parameter */
15480       unreachable = 0;
15481       for (sub_current = catch;
15482            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15483         {
15484           tree sub_catch_clause, decl;
15485           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15486           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15487
15488           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15489             {
15490               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15491               parse_error_context
15492                 (wfl_operator,
15493                  "`catch' not reached because of the catch clause at line %d",
15494                  EXPR_WFL_LINENO (sub_current));
15495               unreachable = error_found = 1;
15496               break;
15497             }
15498         }
15499       /* Complete the catch clause block */
15500       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15501       if (catch_block == error_mark_node)
15502         {
15503           error_found = 1;
15504           continue;
15505         }
15506       if (CAN_COMPLETE_NORMALLY (catch_block))
15507         CAN_COMPLETE_NORMALLY (node) = 1;
15508       TREE_OPERAND (current, 0) = catch_block;
15509
15510       if (unreachable)
15511         continue;
15512
15513       /* Things to do here: the exception must be thrown */
15514
15515       /* Link this type to the caught type list */
15516       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15517     }
15518
15519   PUSH_EXCEPTIONS (caught_type_list);
15520   if ((try = java_complete_tree (try)) == error_mark_node)
15521     error_found = 1;
15522   if (CAN_COMPLETE_NORMALLY (try))
15523     CAN_COMPLETE_NORMALLY (node) = 1;
15524   POP_EXCEPTIONS ();
15525
15526   /* Verification ends here */
15527   if (error_found)
15528     return error_mark_node;
15529
15530   TREE_OPERAND (node, 0) = try;
15531   TREE_OPERAND (node, 1) = catch;
15532   TREE_TYPE (node) = void_type_node;
15533   return node;
15534 }
15535
15536 /* 14.17 The synchronized Statement */
15537
15538 static tree
15539 patch_synchronized_statement (tree node, tree wfl_op1)
15540 {
15541   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15542   tree block = TREE_OPERAND (node, 1);
15543
15544   tree tmp, enter, exit, expr_decl, assignment;
15545
15546   if (expr == error_mark_node)
15547     {
15548       block = java_complete_tree (block);
15549       return expr;
15550     }
15551
15552   /* We might be trying to synchronize on a STRING_CST */
15553   if ((tmp = patch_string (expr)))
15554     expr = tmp;
15555
15556   /* The TYPE of expr must be a reference type */
15557   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15558     {
15559       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15560       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15561                            lang_printable_name (TREE_TYPE (expr), 0));
15562       return error_mark_node;
15563     }
15564
15565   if (flag_emit_xref)
15566     {
15567       TREE_OPERAND (node, 0) = expr;
15568       TREE_OPERAND (node, 1) = java_complete_tree (block);
15569       CAN_COMPLETE_NORMALLY (node) = 1;
15570       return node;
15571     }
15572
15573   /* Generate a try-finally for the synchronized statement, except
15574      that the handler that catches all throw exception calls
15575      _Jv_MonitorExit and then rethrow the exception.
15576      The synchronized statement is then implemented as:
15577      TRY
15578        {
15579          _Jv_MonitorEnter (expression)
15580          synchronized_block
15581          _Jv_MonitorExit (expression)
15582        }
15583      CATCH_ALL
15584        {
15585          e = _Jv_exception_info ();
15586          _Jv_MonitorExit (expression)
15587          Throw (e);
15588        } */
15589
15590   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15591   BUILD_MONITOR_ENTER (enter, expr_decl);
15592   BUILD_MONITOR_EXIT (exit, expr_decl);
15593   CAN_COMPLETE_NORMALLY (enter) = 1;
15594   CAN_COMPLETE_NORMALLY (exit) = 1;
15595   assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15596   TREE_SIDE_EFFECTS (assignment) = 1;
15597   node = build (COMPOUND_EXPR, NULL_TREE,
15598                 build (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15599                 build (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15600   node = build_expr_block (node, expr_decl);
15601
15602   return java_complete_tree (node);
15603 }
15604
15605 /* 14.16 The throw Statement */
15606
15607 static tree
15608 patch_throw_statement (tree node, tree wfl_op1)
15609 {
15610   tree expr = TREE_OPERAND (node, 0);
15611   tree type = TREE_TYPE (expr);
15612   int unchecked_ok = 0, tryblock_throws_ok = 0;
15613
15614   /* Thrown expression must be assignable to java.lang.Throwable */
15615   if (!try_reference_assignconv (throwable_type_node, expr))
15616     {
15617       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15618       parse_error_context (wfl_operator,
15619     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15620                            lang_printable_name (type, 0));
15621       /* If the thrown expression was a reference, we further the
15622          compile-time check. */
15623       if (!JREFERENCE_TYPE_P (type))
15624         return error_mark_node;
15625     }
15626
15627   /* At least one of the following must be true */
15628
15629   /* The type of the throw expression is a not checked exception,
15630      i.e. is a unchecked expression. */
15631   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15632
15633   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15634   /* An instance can't throw a checked exception unless that exception
15635      is explicitly declared in the `throws' clause of each
15636      constructor. This doesn't apply to anonymous classes, since they
15637      don't have declared constructors. */
15638   if (!unchecked_ok
15639       && DECL_INSTINIT_P (current_function_decl)
15640       && !ANONYMOUS_CLASS_P (current_class))
15641     {
15642       tree current;
15643       for (current = TYPE_METHODS (current_class); current;
15644            current = TREE_CHAIN (current))
15645         if (DECL_CONSTRUCTOR_P (current)
15646             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15647           {
15648             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)",
15649                                  lang_printable_name (TREE_TYPE (expr), 0));
15650             return error_mark_node;
15651           }
15652     }
15653
15654   /* Throw is contained in a try statement and at least one catch
15655      clause can receive the thrown expression or the current method is
15656      declared to throw such an exception. Or, the throw statement is
15657      contained in a method or constructor declaration and the type of
15658      the Expression is assignable to at least one type listed in the
15659      throws clause the declaration. */
15660   if (!unchecked_ok)
15661     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15662   if (!(unchecked_ok || tryblock_throws_ok))
15663     {
15664       /* If there is a surrounding try block that has no matching
15665          clatch clause, report it first. A surrounding try block exits
15666          only if there is something after the list of checked
15667          exception thrown by the current function (if any). */
15668       if (IN_TRY_BLOCK_P ())
15669         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15670                              lang_printable_name (type, 0));
15671       /* If we have no surrounding try statement and the method doesn't have
15672          any throws, report it now. FIXME */
15673
15674       /* We report that the exception can't be throw from a try block
15675          in all circumstances but when the `throw' is inside a static
15676          block. */
15677       else if (!EXCEPTIONS_P (currently_caught_type_list)
15678                && !tryblock_throws_ok)
15679         {
15680           if (DECL_CLINIT_P (current_function_decl))
15681             parse_error_context (wfl_operator,
15682                    "Checked exception `%s' can't be thrown in initializer",
15683                                  lang_printable_name (type, 0));
15684           else
15685             parse_error_context (wfl_operator,
15686                    "Checked exception `%s' isn't thrown from a `try' block",
15687                                  lang_printable_name (type, 0));
15688         }
15689       /* Otherwise, the current method doesn't have the appropriate
15690          throws declaration */
15691       else
15692         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15693                              lang_printable_name (type, 0));
15694       return error_mark_node;
15695     }
15696
15697   if (! flag_emit_class_files && ! flag_emit_xref)
15698     BUILD_THROW (node, expr);
15699
15700   /* If doing xrefs, keep the location where the `throw' was seen. */
15701   if (flag_emit_xref)
15702     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15703   return node;
15704 }
15705
15706 /* Check that exception said to be thrown by method DECL can be
15707    effectively caught from where DECL is invoked.  THIS_EXPR is the
15708    expression that computes `this' for the method call.  */
15709 static void
15710 check_thrown_exceptions (int location, tree decl, tree this_expr)
15711 {
15712   tree throws;
15713   int is_array_call = 0;
15714
15715   /* Skip check within generated methods, such as access$<n>.  */
15716   if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
15717     return;
15718
15719   if (this_expr != NULL_TREE
15720       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15721       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15722     is_array_call = 1;
15723
15724   /* For all the unchecked exceptions thrown by DECL.  */
15725   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15726        throws = TREE_CHAIN (throws))
15727     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15728       {
15729         /* Suppress errors about cloning arrays.  */
15730         if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15731           continue;
15732
15733         EXPR_WFL_LINECOL (wfl_operator) = location;
15734         if (DECL_FINIT_P (current_function_decl))
15735           parse_error_context
15736             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15737              lang_printable_name (TREE_VALUE (throws), 0));
15738         else
15739           {
15740             parse_error_context
15741               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15742                lang_printable_name (TREE_VALUE (throws), 0),
15743                (DECL_INIT_P (current_function_decl) ?
15744                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15745                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15746           }
15747       }
15748 }
15749
15750 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15751    try-catch blocks, OR is listed in the `throws' clause of the
15752    current method.  */
15753
15754 static int
15755 check_thrown_exceptions_do (tree exception)
15756 {
15757   tree list = currently_caught_type_list;
15758   resolve_and_layout (exception, NULL_TREE);
15759   /* First, all the nested try-catch-finally at that stage. The
15760      last element contains `throws' clause exceptions, if any. */
15761   if (IS_UNCHECKED_EXCEPTION_P (exception))
15762     return 1;
15763   while (list)
15764     {
15765       tree caught;
15766       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15767         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15768           return 1;
15769       list = TREE_CHAIN (list);
15770     }
15771   return 0;
15772 }
15773
15774 static void
15775 purge_unchecked_exceptions (tree mdecl)
15776 {
15777   tree throws = DECL_FUNCTION_THROWS (mdecl);
15778   tree new = NULL_TREE;
15779
15780   while (throws)
15781     {
15782       tree next = TREE_CHAIN (throws);
15783       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15784         {
15785           TREE_CHAIN (throws) = new;
15786           new = throws;
15787         }
15788       throws = next;
15789     }
15790   /* List is inverted here, but it doesn't matter */
15791   DECL_FUNCTION_THROWS (mdecl) = new;
15792 }
15793
15794 /* This function goes over all of CLASS_TYPE ctors and checks whether
15795    each of them features at least one unchecked exception in its
15796    `throws' clause. If it's the case, it returns `true', `false'
15797    otherwise.  */
15798
15799 static bool
15800 ctors_unchecked_throws_clause_p (tree class_type)
15801 {
15802   tree current;
15803
15804   for (current = TYPE_METHODS (class_type); current;
15805        current = TREE_CHAIN (current))
15806     {
15807       bool ctu = false; /* Ctor Throws Unchecked */
15808       if (DECL_CONSTRUCTOR_P (current))
15809         {
15810           tree throws;
15811           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15812                throws = TREE_CHAIN (throws))
15813             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15814               ctu = true;
15815         }
15816       /* We return false as we found one ctor that is unfit. */
15817       if (!ctu && DECL_CONSTRUCTOR_P (current))
15818         return false;
15819     }
15820   /* All ctors feature at least one unchecked exception in their
15821      `throws' clause. */
15822   return true;
15823 }
15824
15825 /* 15.24 Conditional Operator ?: */
15826
15827 static tree
15828 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15829 {
15830   tree cond = TREE_OPERAND (node, 0);
15831   tree op1 = TREE_OPERAND (node, 1);
15832   tree op2 = TREE_OPERAND (node, 2);
15833   tree resulting_type = NULL_TREE;
15834   tree t1, t2, patched;
15835   int error_found = 0;
15836
15837   /* Operands of ?: might be StringBuffers crafted as a result of a
15838      string concatenation. Obtain a descent operand here.  */
15839   if ((patched = patch_string (op1)))
15840     TREE_OPERAND (node, 1) = op1 = patched;
15841   if ((patched = patch_string (op2)))
15842     TREE_OPERAND (node, 2) = op2 = patched;
15843
15844   t1 = TREE_TYPE (op1);
15845   t2 = TREE_TYPE (op2);
15846
15847   /* The first expression must be a boolean */
15848   if (TREE_TYPE (cond) != boolean_type_node)
15849     {
15850       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15851       parse_error_context (wfl_operator,
15852                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15853                            lang_printable_name (TREE_TYPE (cond), 0));
15854       error_found = 1;
15855     }
15856
15857   /* Second and third can be numeric, boolean (i.e. primitive),
15858      references or null. Anything else results in an error */
15859   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15860         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15861             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15862         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15863     error_found = 1;
15864
15865   /* Determine the type of the conditional expression. Same types are
15866      easy to deal with */
15867   else if (t1 == t2)
15868     resulting_type = t1;
15869
15870   /* There are different rules for numeric types */
15871   else if (JNUMERIC_TYPE_P (t1))
15872     {
15873       /* if byte/short found, the resulting type is short */
15874       if ((t1 == byte_type_node && t2 == short_type_node)
15875           || (t1 == short_type_node && t2 == byte_type_node))
15876         resulting_type = short_type_node;
15877
15878       /* If t1 is a constant int and t2 is of type byte, short or char
15879          and t1's value fits in t2, then the resulting type is t2 */
15880       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15881           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15882         resulting_type = t2;
15883
15884       /* If t2 is a constant int and t1 is of type byte, short or char
15885          and t2's value fits in t1, then the resulting type is t1 */
15886       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15887           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15888         resulting_type = t1;
15889
15890       /* Otherwise, binary numeric promotion is applied and the
15891          resulting type is the promoted type of operand 1 and 2 */
15892       else
15893         resulting_type = binary_numeric_promotion (t1, t2,
15894                                                    &TREE_OPERAND (node, 1),
15895                                                    &TREE_OPERAND (node, 2));
15896     }
15897
15898   /* Cases of a reference and a null type */
15899   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15900     resulting_type = t1;
15901
15902   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15903     resulting_type = t2;
15904
15905   /* Last case: different reference types. If a type can be converted
15906      into the other one by assignment conversion, the latter
15907      determines the type of the expression */
15908   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15909     resulting_type = promote_type (t1);
15910
15911   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15912     resulting_type = promote_type (t2);
15913
15914   /* If we don't have any resulting type, we're in trouble */
15915   if (!resulting_type)
15916     {
15917       char *t = xstrdup (lang_printable_name (t1, 0));
15918       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15919       parse_error_context (wfl_operator,
15920                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15921                            t, lang_printable_name (t2, 0));
15922       free (t);
15923       error_found = 1;
15924     }
15925
15926   if (error_found)
15927     {
15928       TREE_TYPE (node) = error_mark_node;
15929       return error_mark_node;
15930     }
15931
15932   TREE_TYPE (node) = resulting_type;
15933   TREE_SET_CODE (node, COND_EXPR);
15934   CAN_COMPLETE_NORMALLY (node) = 1;
15935   return node;
15936 }
15937
15938 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15939
15940 static tree
15941 maybe_build_class_init_for_field (tree decl, tree expr)
15942 {
15943   tree clas = DECL_CONTEXT (decl);
15944   if (flag_emit_class_files || flag_emit_xref)
15945     return expr;
15946
15947   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
15948       && FIELD_FINAL (decl))
15949     {
15950       tree init = DECL_INITIAL (decl);
15951       if (init != NULL_TREE)
15952         init = fold_constant_for_init (init, decl);
15953       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
15954         return expr;
15955     }
15956
15957   return build_class_init (clas, expr);
15958 }
15959
15960 /* Try to constant fold NODE.
15961    If NODE is not a constant expression, return NULL_EXPR.
15962    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15963
15964 static tree
15965 fold_constant_for_init (tree node, tree context)
15966 {
15967   tree op0, op1, val;
15968   enum tree_code code = TREE_CODE (node);
15969
15970   switch (code)
15971     {
15972     case INTEGER_CST:
15973       if (node == null_pointer_node)
15974         return NULL_TREE;
15975     case STRING_CST:
15976     case REAL_CST:
15977       return node;
15978
15979     case PLUS_EXPR:
15980     case MINUS_EXPR:
15981     case MULT_EXPR:
15982     case TRUNC_MOD_EXPR:
15983     case RDIV_EXPR:
15984     case LSHIFT_EXPR:
15985     case RSHIFT_EXPR:
15986     case URSHIFT_EXPR:
15987     case BIT_AND_EXPR:
15988     case BIT_XOR_EXPR:
15989     case BIT_IOR_EXPR:
15990     case TRUTH_ANDIF_EXPR:
15991     case TRUTH_ORIF_EXPR:
15992     case EQ_EXPR:
15993     case NE_EXPR:
15994     case GT_EXPR:
15995     case GE_EXPR:
15996     case LT_EXPR:
15997     case LE_EXPR:
15998       op0 = TREE_OPERAND (node, 0);
15999       op1 = TREE_OPERAND (node, 1);
16000       val = fold_constant_for_init (op0, context);
16001       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16002         return NULL_TREE;
16003       TREE_OPERAND (node, 0) = val;
16004       val = fold_constant_for_init (op1, context);
16005       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16006         return NULL_TREE;
16007       TREE_OPERAND (node, 1) = val;
16008       return patch_binop (node, op0, op1);
16009
16010     case UNARY_PLUS_EXPR:
16011     case NEGATE_EXPR:
16012     case TRUTH_NOT_EXPR:
16013     case BIT_NOT_EXPR:
16014     case CONVERT_EXPR:
16015       op0 = TREE_OPERAND (node, 0);
16016       val = fold_constant_for_init (op0, context);
16017       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16018         return NULL_TREE;
16019       TREE_OPERAND (node, 0) = val;
16020       val = patch_unaryop (node, op0);
16021       if (! TREE_CONSTANT (val))
16022         return NULL_TREE;
16023       return val;
16024
16025       break;
16026
16027     case COND_EXPR:
16028       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
16029       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16030         return NULL_TREE;
16031       TREE_OPERAND (node, 0) = val;
16032       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
16033       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16034         return NULL_TREE;
16035       TREE_OPERAND (node, 1) = val;
16036       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
16037       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16038         return NULL_TREE;
16039       TREE_OPERAND (node, 2) = val;
16040       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
16041         : TREE_OPERAND (node, 2);
16042
16043     case VAR_DECL:
16044     case FIELD_DECL:
16045       if (! FIELD_FINAL (node)
16046           || DECL_INITIAL (node) == NULL_TREE)
16047         return NULL_TREE;
16048       val = DECL_INITIAL (node);
16049       /* Guard against infinite recursion. */
16050       DECL_INITIAL (node) = NULL_TREE;
16051       val = fold_constant_for_init (val, node);
16052       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
16053         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
16054       DECL_INITIAL (node) = val;
16055       return val;
16056
16057     case EXPR_WITH_FILE_LOCATION:
16058       /* Compare java_complete_tree and resolve_expression_name. */
16059       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
16060           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
16061         {
16062           tree name = EXPR_WFL_NODE (node);
16063           tree decl;
16064           if (PRIMARY_P (node))
16065             return NULL_TREE;
16066           else if (! QUALIFIED_P (name))
16067             {
16068               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
16069               if (decl == NULL_TREE
16070                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16071                 return NULL_TREE;
16072               return fold_constant_for_init (decl, decl);
16073             }
16074           else
16075             {
16076               /* Install the proper context for the field resolution.
16077                  The prior context is restored once the name is
16078                  properly qualified. */
16079               tree saved_current_class = current_class;
16080               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
16081               current_class = DECL_CONTEXT (context);
16082               qualify_ambiguous_name (node);
16083               current_class = saved_current_class;
16084               if (resolve_field_access (node, &decl, NULL)
16085                   && decl != NULL_TREE)
16086                 return fold_constant_for_init (decl, decl);
16087               return NULL_TREE;
16088             }
16089         }
16090       else
16091         {
16092           op0 = TREE_OPERAND (node, 0);
16093           val = fold_constant_for_init (op0, context);
16094           if (val == NULL_TREE || ! TREE_CONSTANT (val))
16095             return NULL_TREE;
16096           TREE_OPERAND (node, 0) = val;
16097           return val;
16098         }
16099
16100 #ifdef USE_COMPONENT_REF
16101     case IDENTIFIER:
16102     case COMPONENT_REF:
16103       ?;
16104 #endif
16105
16106     default:
16107       return NULL_TREE;
16108     }
16109 }
16110
16111 #ifdef USE_COMPONENT_REF
16112 /* Context is 'T' for TypeName, 'P' for PackageName,
16113    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16114
16115 tree
16116 resolve_simple_name (tree name, int context)
16117 {
16118 }
16119
16120 tree
16121 resolve_qualified_name (tree name, int context)
16122 {
16123 }
16124 #endif
16125
16126 void
16127 init_src_parse (void)
16128 {
16129   /* Sanity check; we've been bit by this before.  */
16130   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16131     abort ();
16132 }
16133
16134 \f
16135
16136 /* This section deals with the functions that are called when tables
16137    recording class initialization information are traversed.  */
16138
16139 /* Attach to PTR (a block) the declaration found in ENTRY. */
16140
16141 static int
16142 attach_init_test_initialization_flags (void **entry, void *ptr)
16143 {
16144   tree block = (tree)ptr;
16145   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16146
16147   if (block != error_mark_node)
16148     {
16149       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16150       BLOCK_EXPR_DECLS (block) = ite->value;
16151     }
16152   return true;
16153 }
16154
16155 /* This function is called for each class that is known definitely
16156    initialized when a given static method was called. This function
16157    augments a compound expression (INFO) storing all assignment to
16158    initialized static class flags if a flag already existed, otherwise
16159    a new one is created.  */
16160
16161 static int
16162 emit_test_initialization (void **entry_p, void *info)
16163 {
16164   tree l = (tree) info;
16165   tree decl, init;
16166   tree key = (tree) *entry_p;
16167   tree *ite;
16168   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16169
16170   /* If we haven't found a flag and we're dealing with self registered
16171      with current_function_decl, then don't do anything. Self is
16172      always added as definitely initialized but this information is
16173      valid only if used outside the current function. */
16174   if (current_function_decl == TREE_PURPOSE (l)
16175       && java_treetreehash_find (cf_ht, key) == NULL)
16176     return true;
16177
16178   ite = java_treetreehash_new (cf_ht, key);
16179
16180   /* If we don't have a variable, create one and install it. */
16181   if (*ite == NULL)
16182     {
16183       tree block;
16184
16185       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16186       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16187       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16188       DECL_CONTEXT (decl) = current_function_decl;
16189       DECL_INITIAL (decl) = boolean_true_node;
16190       /* Don't emit any symbolic debugging info for this decl.  */
16191       DECL_IGNORED_P (decl) = 1;
16192
16193       /* The trick is to find the right context for it. */
16194       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16195       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16196       BLOCK_EXPR_DECLS (block) = decl;
16197       *ite = decl;
16198     }
16199   else
16200     decl = *ite;
16201
16202   /* Now simply augment the compound that holds all the assignments
16203      pertaining to this method invocation. */
16204   init = build (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16205   TREE_SIDE_EFFECTS (init) = 1;
16206   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16207   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16208
16209   return true;
16210 }
16211
16212 #include "gt-java-parse.h"
16213 #include "gtype-java.h"