gcc/java/parse.y

   1 /* Source code parsing and tree node generation for the GNU compiler
   2    for the Java(TM) language.
   3    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
   4    Free Software Foundation, Inc.
   5    Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.
  23
  24 Java and all Java-based marks are trademarks or registered trademarks
  25 of Sun Microsystems, Inc. in the United States and other countries.
  26 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  27
  28 /* This file parses java source code and issues a tree node image
  29 suitable for code generation (byte code and targeted CPU assembly
  30 language).
  31
  32 The grammar conforms to the Java grammar described in "The Java(TM)
  33 Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
  34 1996, ISBN 0-201-63451-1"
  35
  36 The following modifications were brought to the original grammar:
  37
  38 method_body: added the rule '| block SC_TK'
  39 static_initializer: added the rule 'static block SC_TK'.
  40
  41 Note: All the extra rules described above should go away when the
  42       empty_statement rule will work.
  43
  44 statement_nsi: 'nsi' should be read no_short_if.
  45
  46 Some rules have been modified to support JDK1.1 inner classes
  47 definitions and other extensions.  */
  48
  49 %{
  50 #include "config.h"
  51 #include "system.h"
  52 #include "coretypes.h"
  53 #include "tm.h"
  54 #include <dirent.h>
  55 #include "tree.h"
  56 #include "rtl.h"
  57 #include "real.h"
  58 #include "obstack.h"
  59 #include "toplev.h"
  60 #include "flags.h"
  61 #include "java-tree.h"
  62 #include "jcf.h"
  63 #include "lex.h"
  64 #include "parse.h"
  65 #include "zipfile.h"
  66 #include "convert.h"
  67 #include "buffer.h"
  68 #include "xref.h"
  69 #include "function.h"
  70 #include "except.h"
  71 #include "ggc.h"
  72 #include "debug.h"
  73 #include "tree-inline.h"
  74 #include "cgraph.h"
  75 #include "target.h"
  76
  77 /* Local function prototypes */
  78 static char *java_accstring_lookup (int);
  79 static const char *accessibility_string (int);
  80 static void  classitf_redefinition_error (const char *,tree, tree, tree);
  81 static void  variable_redefinition_error (tree, tree, tree, int);
  82 static tree  create_class (int, tree, tree, tree);
  83 static tree  create_interface (int, tree, tree);
  84 static void  end_class_declaration (int);
  85 static tree  find_field (tree, tree);
  86 static tree lookup_field_wrapper (tree, tree);
  87 static int   duplicate_declaration_error_p (tree, tree, tree);
  88 static void  register_fields (int, tree, tree);
  89 static tree parser_qualified_classname (tree);
  90 static int  parser_check_super (tree, tree, tree);
  91 static int  parser_check_super_interface (tree, tree, tree);
  92 static void check_modifiers_consistency (int);
  93 static tree lookup_cl (tree);
  94 static tree lookup_java_method2 (tree, tree, int);
  95 static tree method_header (int, tree, tree, tree);
  96 static void fix_method_argument_names (tree ,tree);
  97 static tree method_declarator (tree, tree);
  98 static void parse_warning_context (tree cl, const char *msg, ...)
  99   ATTRIBUTE_PRINTF_2;
 100 static void issue_warning_error_from_context (tree, const char *msg, va_list)
 101   ATTRIBUTE_PRINTF (2, 0);
 102 static void parse_ctor_invocation_error (void);
 103 static tree parse_jdk1_1_error (const char *);
 104 static void complete_class_report_errors (jdep *);
 105 static int process_imports (void);
 106 static void read_import_dir (tree);
 107 static int find_in_imports_on_demand (tree, tree);
 108 static void find_in_imports (tree, tree);
 109 static void check_inner_class_access (tree, tree, tree);
 110 static int check_pkg_class_access (tree, tree, bool, tree);
 111 static void register_package (tree);
 112 static tree resolve_package (tree, tree *, tree *);
 113 static tree resolve_class (tree, tree, tree, tree);
 114 static void declare_local_variables (int, tree, tree);
 115 static void dump_java_tree (enum tree_dump_index, tree);
 116 static void source_start_java_method (tree);
 117 static void source_end_java_method (void);
 118 static tree find_name_in_single_imports (tree);
 119 static void check_abstract_method_header (tree);
 120 static tree lookup_java_interface_method2 (tree, tree);
 121 static tree resolve_expression_name (tree, tree *);
 122 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
 123 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
 124 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
 125 static int breakdown_qualified (tree *, tree *, tree);
 126 static int in_same_package (tree, tree);
 127 static tree resolve_and_layout (tree, tree);
 128 static tree qualify_and_find (tree, tree, tree);
 129 static tree resolve_no_layout (tree, tree);
 130 static int invocation_mode (tree, int);
 131 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
 132 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
 133 static tree find_most_specific_methods_list (tree);
 134 static int argument_types_convertible (tree, tree);
 135 static tree patch_invoke (tree, tree, tree);
 136 static int maybe_use_access_method (int, tree *, tree *);
 137 static tree lookup_method_invoke (int, tree, tree, tree, tree);
 138 static tree register_incomplete_type (int, tree, tree, tree);
 139 static tree check_inner_circular_reference (tree, tree);
 140 static tree check_circular_reference (tree);
 141 static tree obtain_incomplete_type (tree);
 142 static tree java_complete_lhs (tree);
 143 static tree java_complete_tree (tree);
 144 static tree maybe_generate_pre_expand_clinit (tree);
 145 static int analyze_clinit_body (tree, tree);
 146 static int maybe_yank_clinit (tree);
 147 static void start_complete_expand_method (tree);
 148 static void java_complete_expand_method (tree);
 149 static void java_expand_method_bodies (tree);
 150 static int  unresolved_type_p (tree, tree *);
 151 static void create_jdep_list (struct parser_ctxt *);
 152 static tree build_expr_block (tree, tree);
 153 static tree enter_block (void);
 154 static tree exit_block (void);
 155 static tree lookup_name_in_blocks (tree);
 156 static void maybe_absorb_scoping_blocks (void);
 157 static tree build_method_invocation (tree, tree);
 158 static tree build_new_invocation (tree, tree);
 159 static tree build_assignment (int, int, tree, tree);
 160 static tree build_binop (enum tree_code, int, tree, tree);
 161 static tree patch_assignment (tree, tree);
 162 static tree patch_binop (tree, tree, tree);
 163 static tree build_unaryop (int, int, tree);
 164 static tree build_incdec (int, int, tree, int);
 165 static tree patch_unaryop (tree, tree);
 166 static tree build_cast (int, tree, tree);
 167 static tree build_null_of_type (tree);
 168 static tree patch_cast (tree, tree);
 169 static int valid_ref_assignconv_cast_p (tree, tree, int);
 170 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
 171 static int valid_cast_to_p (tree, tree);
 172 static int valid_method_invocation_conversion_p (tree, tree);
 173 static tree try_builtin_assignconv (tree, tree, tree);
 174 static tree try_reference_assignconv (tree, tree);
 175 static tree build_unresolved_array_type (tree);
 176 static int build_type_name_from_array_name (tree, tree *);
 177 static tree build_array_from_name (tree, tree, tree, tree *);
 178 static tree build_array_ref (int, tree, tree);
 179 static tree patch_array_ref (tree);
 180 static tree make_qualified_name (tree, tree, int);
 181 static tree merge_qualified_name (tree, tree);
 182 static tree make_qualified_primary (tree, tree, int);
 183 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
 184 static void qualify_ambiguous_name (tree);
 185 static tree resolve_field_access (tree, tree *, tree *);
 186 static tree build_newarray_node (tree, tree, int);
 187 static tree patch_newarray (tree);
 188 static tree resolve_type_during_patch (tree);
 189 static tree build_this (int);
 190 static tree build_wfl_wrap (tree, int);
 191 static tree build_return (int, tree);
 192 static tree patch_return (tree);
 193 static tree maybe_access_field (tree, tree, tree);
 194 static int complete_function_arguments (tree);
 195 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
 196 static int not_accessible_p (tree, tree, tree, int);
 197 static void check_deprecation (tree, tree);
 198 static int class_in_current_package (tree);
 199 static tree build_if_else_statement (int, tree, tree, tree);
 200 static tree patch_if_else_statement (tree);
 201 static tree add_stmt_to_block (tree, tree, tree);
 202 static tree patch_exit_expr (tree);
 203 static tree build_labeled_block (int, tree);
 204 static tree finish_labeled_statement (tree, tree);
 205 static tree build_bc_statement (int, int, tree);
 206 static tree patch_bc_statement (tree);
 207 static tree patch_loop_statement (tree);
 208 static tree build_new_loop (tree);
 209 static tree build_loop_body (int, tree, int);
 210 static tree finish_loop_body (int, tree, tree, int);
 211 static tree build_debugable_stmt (int, tree);
 212 static tree finish_for_loop (int, tree, tree, tree);
 213 static tree patch_switch_statement (tree);
 214 static tree string_constant_concatenation (tree, tree);
 215 static tree build_string_concatenation (tree, tree);
 216 static tree patch_string_cst (tree);
 217 static tree patch_string (tree);
 218 static tree encapsulate_with_try_catch (int, tree, tree, tree);
 219 static tree build_assertion (int, tree, tree);
 220 static tree build_try_statement (int, tree, tree);
 221 static tree build_try_finally_statement (int, tree, tree);
 222 static tree patch_try_statement (tree);
 223 static tree patch_synchronized_statement (tree, tree);
 224 static tree patch_throw_statement (tree, tree);
 225 static void check_thrown_exceptions (int, tree, tree);
 226 static int check_thrown_exceptions_do (tree);
 227 static void purge_unchecked_exceptions (tree);
 228 static bool ctors_unchecked_throws_clause_p (tree);
 229 static void check_concrete_throws_clauses (tree, tree, tree, tree);
 230 static void check_throws_clauses (tree, tree, tree);
 231 static void finish_method_declaration (tree);
 232 static tree build_super_invocation (tree);
 233 static int verify_constructor_circularity (tree, tree);
 234 static char *constructor_circularity_msg (tree, tree);
 235 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
 236 static const char *get_printable_method_name (tree);
 237 static tree patch_conditional_expr (tree, tree, tree);
 238 static tree generate_finit (tree);
 239 static tree generate_instinit (tree);
 240 static tree build_instinit_invocation (tree);
 241 static void fix_constructors (tree);
 242 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
 243 static tree craft_constructor (tree, tree);
 244 static int verify_constructor_super (tree);
 245 static tree create_artificial_method (tree, int, tree, tree, tree);
 246 static void start_artificial_method_body (tree);
 247 static void end_artificial_method_body (tree);
 248 static int check_method_redefinition (tree, tree);
 249 static int check_method_types_complete (tree);
 250 static bool hack_is_accessible_p (tree, tree);
 251 static void java_check_regular_methods (tree);
 252 static void check_interface_throws_clauses (tree, tree);
 253 static void java_check_abstract_methods (tree);
 254 static void unreachable_stmt_error (tree);
 255 static int not_accessible_field_error (tree, tree);
 256 static tree find_expr_with_wfl (tree);
 257 static void missing_return_error (tree);
 258 static tree build_new_array_init (int, tree);
 259 static tree patch_new_array_init (tree, tree);
 260 static tree maybe_build_array_element_wfl (tree);
 261 static int array_constructor_check_entry (tree, tree);
 262 static const char *purify_type_name (const char *);
 263 static tree fold_constant_for_init (tree, tree);
 264 static tree strip_out_static_field_access_decl (tree);
 265 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
 266 static void static_ref_err (tree, tree, tree);
 267 static void parser_add_interface (tree, tree, tree);
 268 static void add_superinterfaces (tree, tree);
 269 static tree jdep_resolve_class (jdep *);
 270 static int note_possible_classname (const char *, int);
 271 static void java_complete_expand_classes (void);
 272 static void java_complete_expand_class (tree);
 273 static void java_complete_expand_methods (tree);
 274 static tree cut_identifier_in_qualified (tree);
 275 static tree java_stabilize_reference (tree);
 276 static tree do_unary_numeric_promotion (tree);
 277 static char * operator_string (tree);
 278 static tree do_merge_string_cste (tree, const char *, int, int);
 279 static tree merge_string_cste (tree, tree, int);
 280 static tree java_refold (tree);
 281 static int java_decl_equiv (tree, tree);
 282 static int binop_compound_p (enum tree_code);
 283 static tree search_loop (tree);
 284 static int labeled_block_contains_loop_p (tree, tree);
 285 static int check_abstract_method_definitions (int, tree, tree);
 286 static void java_check_abstract_method_definitions (tree);
 287 static void java_debug_context_do (int);
 288 static void java_parser_context_push_initialized_field (void);
 289 static void java_parser_context_pop_initialized_field (void);
 290 static tree reorder_static_initialized (tree);
 291 static void java_parser_context_suspend (void);
 292 static void java_parser_context_resume (void);
 293 static int pop_current_osb (struct parser_ctxt *);
 294
 295 /* JDK 1.1 work. FIXME */
 296
 297 static tree maybe_make_nested_class_name (tree);
 298 static int make_nested_class_name (tree);
 299 static void set_nested_class_simple_name_value (tree, int);
 300 static void link_nested_class_to_enclosing (void);
 301 static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
 302 static tree find_as_inner_class (tree, tree, tree);
 303 static tree find_as_inner_class_do (tree, tree);
 304 static int check_inner_class_redefinition (tree, tree);
 305
 306 static tree build_thisn_assign (void);
 307 static tree build_current_thisn (tree);
 308 static tree build_access_to_thisn (tree, tree, int);
 309 static tree maybe_build_thisn_access_method (tree);
 310
 311 static tree build_outer_field_access (tree, tree);
 312 static tree build_outer_field_access_methods (tree);
 313 static tree build_outer_field_access_expr (int, tree, tree,
 314                                                   tree, tree);
 315 static tree build_outer_method_access_method (tree);
 316 static tree build_new_access_id (void);
 317 static tree build_outer_field_access_method (tree, tree, tree,
 318                                                     tree, tree);
 319
 320 static int outer_field_access_p (tree, tree);
 321 static int outer_field_expanded_access_p (tree, tree *,
 322                                                  tree *, tree *);
 323 static tree outer_field_access_fix (tree, tree, tree);
 324 static tree build_incomplete_class_ref (int, tree);
 325 static tree patch_incomplete_class_ref (tree);
 326 static tree create_anonymous_class (int, tree);
 327 static void patch_anonymous_class (tree, tree, tree);
 328 static void add_inner_class_fields (tree, tree);
 329
 330 static tree build_dot_class_method (tree);
 331 static tree build_dot_class_method_invocation (tree, tree);
 332 static void create_new_parser_context (int);
 333 static tree maybe_build_class_init_for_field (tree, tree);
 334
 335 static int attach_init_test_initialization_flags (void **, void *);
 336 static int emit_test_initialization (void **, void *);
 337
 338 static char *string_convert_int_cst (tree);
 339
 340 /* Number of error found so far. */
 341 int java_error_count;
 342 /* Number of warning found so far. */
 343 int java_warning_count;
 344 /* Tell when not to fold, when doing xrefs */
 345 int do_not_fold;
 346 /* Cyclic inheritance report, as it can be set by layout_class */
 347 const char *cyclic_inheritance_report;
 348
 349 /* The current parser context */
 350 struct parser_ctxt *ctxp;
 351
 352 /* List of things that were analyzed for which code will be generated */
 353 struct parser_ctxt *ctxp_for_generation = NULL;
 354
 355 /* binop_lookup maps token to tree_code. It is used where binary
 356    operations are involved and required by the parser. RDIV_EXPR
 357    covers both integral/floating point division. The code is changed
 358    once the type of both operator is worked out.  */
 359
 360 static const enum tree_code binop_lookup[19] =
 361   {
 362     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
 363     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
 364     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
 365     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
 366     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
 367    };
 368 #define BINOP_LOOKUP(VALUE)                                             \
 369   binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
 370
 371 /* This is the end index for binary operators that can also be used
 372    in compound assignments. */
 373 #define BINOP_COMPOUND_CANDIDATES 11
 374
 375 /* The "$L" identifier we use to create labels.  */
 376 static GTY(()) tree label_id;
 377
 378 /* The "StringBuffer" identifier used for the String `+' operator. */
 379 static GTY(()) tree wfl_string_buffer;
 380
 381 /* The "append" identifier used for String `+' operator.  */
 382 static GTY(()) tree wfl_append;
 383
 384 /* The "toString" identifier used for String `+' operator. */
 385 static GTY(()) tree wfl_to_string;
 386
 387 /* The "java.lang" import qualified name.  */
 388 static GTY(()) tree java_lang_id;
 389
 390 /* The generated `inst$' identifier used for generated enclosing
 391    instance/field access functions.  */
 392 static GTY(()) tree inst_id;
 393
 394 /* Context and flag for static blocks */
 395 static GTY(()) tree current_static_block;
 396
 397 /* The generated `write_parm_value$' identifier.  */
 398 static GTY(()) tree wpv_id;
 399
 400 /* The list of all packages we've seen so far */
 401 static GTY(()) tree package_list;
 402
 403 /* Hold THIS for the scope of the current method decl.  */
 404 static GTY(()) tree current_this;
 405
 406 /* Hold a list of catch clauses list. The first element of this list is
 407    the list of the catch clauses of the currently analyzed try block. */
 408 static GTY(()) tree currently_caught_type_list;
 409
 410 /* This holds a linked list of all the case labels for the current
 411    switch statement.  It is only used when checking to see if there
 412    are duplicate labels.  FIXME: probably this should just be attached
 413    to the switch itself; then it could be referenced via
 414    `ctxp->current_loop'.  */
 415 static GTY(()) tree case_label_list;
 416
 417 /* Anonymous class counter. Will be reset to 1 every time a non
 418    anonymous class gets created. */
 419 static int anonymous_class_counter = 1;
 420
 421 static GTY(()) tree src_parse_roots[1];
 422
 423 /* All classes seen from source code */
 424 #define gclass_list src_parse_roots[0]
 425
 426 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
 427    line and point it out.  */
 428 /* Should point out the one that don't fit. ASCII/unicode, going
 429    backward. FIXME */
 430
 431 #define check_modifiers(__message, __value, __mask) do {        \
 432   if ((__value) & ~(__mask))                                    \
 433     {                                                           \
 434       size_t i, remainder = (__value) & ~(__mask);              \
 435       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)     \
 436         if ((1 << i) & remainder)                               \
 437           parse_error_context (ctxp->modifier_ctx [i], (__message), \
 438                                java_accstring_lookup (1 << i)); \
 439     }                                                           \
 440 } while (0)
 441
 442 %}
 443
 444 %union {
 445   tree node;
 446   int sub_token;
 447   struct {
 448     int token;
 449     int location;
 450   } operator;
 451   int value;
 452 }
 453
 454 %{
 455 #include "lex.c"
 456 %}
 457
 458 %pure_parser
 459
 460 /* Things defined here have to match the order of what's in the
 461    binop_lookup table.  */
 462
 463 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
 464 %token   LS_TK           SRS_TK          ZRS_TK
 465 %token   AND_TK          XOR_TK          OR_TK
 466 %token   BOOL_AND_TK BOOL_OR_TK
 467 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
 468
 469 /* This maps to the same binop_lookup entry than the token above */
 470
 471 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
 472 %token   REM_ASSIGN_TK
 473 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 474 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
 475
 476
 477 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
 478
 479 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
 480 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
 481 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
 482 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
 483 %token   MODIFIER_TK
 484
 485 /* Keep those two in order, too */
 486 %token   DECR_TK INCR_TK
 487
 488 /* From now one, things can be in any order */
 489
 490 %token   DEFAULT_TK      IF_TK              THROW_TK
 491 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
 492 %token   THROWS_TK       BREAK_TK           IMPORT_TK
 493 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
 494 %token   VOID_TK         CATCH_TK           INTERFACE_TK
 495 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
 496 %token   SUPER_TK        WHILE_TK           CLASS_TK
 497 %token   SWITCH_TK       CONST_TK           TRY_TK
 498 %token   FOR_TK          NEW_TK             CONTINUE_TK
 499 %token   GOTO_TK         PACKAGE_TK         THIS_TK
 500 %token   ASSERT_TK
 501
 502 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
 503 %token   CHAR_TK         INTEGRAL_TK
 504
 505 %token   FLOAT_TK        DOUBLE_TK          FP_TK
 506
 507 %token   ID_TK
 508
 509 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
 510
 511 %token   ASSIGN_ANY_TK   ASSIGN_TK
 512 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
 513
 514 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
 515 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
 516
 517 %type    <value>        modifiers MODIFIER_TK final synchronized
 518
 519 %type    <node>         super ID_TK identifier
 520 %type    <node>         name simple_name qualified_name
 521 %type    <node>         type_declaration compilation_unit
 522                         field_declaration method_declaration extends_interfaces
 523                         interfaces interface_type_list
 524                         import_declarations package_declaration
 525                         type_declarations interface_body
 526                         interface_member_declaration constant_declaration
 527                         interface_member_declarations interface_type
 528                         abstract_method_declaration
 529 %type    <node>         class_body_declaration class_member_declaration
 530                         static_initializer constructor_declaration block
 531 %type    <node>         class_body_declarations constructor_header
 532 %type    <node>         class_or_interface_type class_type class_type_list
 533                         constructor_declarator explicit_constructor_invocation
 534 %type    <node>         dim_expr dim_exprs this_or_super throws
 535
 536 %type    <node>         variable_declarator_id variable_declarator
 537                         variable_declarators variable_initializer
 538                         variable_initializers constructor_body
 539                         array_initializer
 540
 541 %type    <node>         class_body block_end constructor_block_end
 542 %type    <node>         statement statement_without_trailing_substatement
 543                         labeled_statement if_then_statement label_decl
 544                         if_then_else_statement while_statement for_statement
 545                         statement_nsi labeled_statement_nsi do_statement
 546                         if_then_else_statement_nsi while_statement_nsi
 547                         for_statement_nsi statement_expression_list for_init
 548                         for_update statement_expression expression_statement
 549                         primary_no_new_array expression primary
 550                         array_creation_expression array_type
 551                         class_instance_creation_expression field_access
 552                         method_invocation array_access something_dot_new
 553                         argument_list postfix_expression while_expression
 554                         post_increment_expression post_decrement_expression
 555                         unary_expression_not_plus_minus unary_expression
 556                         pre_increment_expression pre_decrement_expression
 557                         cast_expression
 558                         multiplicative_expression additive_expression
 559                         shift_expression relational_expression
 560                         equality_expression and_expression
 561                         exclusive_or_expression inclusive_or_expression
 562                         conditional_and_expression conditional_or_expression
 563                         conditional_expression assignment_expression
 564                         left_hand_side assignment for_header for_begin
 565                         constant_expression do_statement_begin empty_statement
 566                         switch_statement synchronized_statement throw_statement
 567                         try_statement assert_statement
 568                         switch_expression switch_block
 569                         catches catch_clause catch_clause_parameter finally
 570                         anonymous_class_creation trap_overflow_corner_case
 571 %type    <node>         return_statement break_statement continue_statement
 572
 573 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
 574 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
 575 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 576 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
 577 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
 578 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
 579 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
 580 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
 581 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
 582 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
 583 %type    <operator>     THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
 584 %type    <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
 585 %type    <operator>     NEW_TK ASSERT_TK
 586
 587 %type    <node>         method_body
 588
 589 %type    <node>         literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
 590                         STRING_LIT_TK NULL_TK VOID_TK
 591
 592 %type    <node>         IF_TK WHILE_TK FOR_TK
 593
 594 %type    <node>         formal_parameter_list formal_parameter
 595                         method_declarator method_header
 596
 597 %type    <node>         primitive_type reference_type type
 598                         BOOLEAN_TK INTEGRAL_TK FP_TK
 599
 600 /* Added or modified JDK 1.1 rule types  */
 601 %type    <node>         type_literals
 602
 603 %%
 604 /* 19.2 Production from 2.3: The Syntactic Grammar  */
 605 goal:  compilation_unit
 606                 {}
 607 ;
 608
 609 /* 19.3 Productions from 3: Lexical structure  */
 610 literal:
 611         INT_LIT_TK
 612 |       FP_LIT_TK
 613 |       BOOL_LIT_TK
 614 |       CHAR_LIT_TK
 615 |       STRING_LIT_TK
 616 |       NULL_TK
 617 ;
 618
 619 /* 19.4 Productions from 4: Types, Values and Variables  */
 620 type:
 621         primitive_type
 622 |       reference_type
 623 ;
 624
 625 primitive_type:
 626         INTEGRAL_TK
 627 |       FP_TK
 628 |       BOOLEAN_TK
 629 ;
 630
 631 reference_type:
 632         class_or_interface_type
 633 |       array_type
 634 ;
 635
 636 class_or_interface_type:
 637         name
 638 ;
 639
 640 class_type:
 641         class_or_interface_type /* Default rule */
 642 ;
 643
 644 interface_type:
 645          class_or_interface_type
 646 ;
 647
 648 array_type:
 649         primitive_type dims
 650                 {
 651                   int osb = pop_current_osb (ctxp);
 652                   tree t = build_java_array_type (($1), -1);
 653                   while (--osb)
 654                     t = build_unresolved_array_type (t);
 655                   $$ = t;
 656                 }
 657 |       name dims
 658                 {
 659                   int osb = pop_current_osb (ctxp);
 660                   tree t = $1;
 661                   while (osb--)
 662                     t = build_unresolved_array_type (t);
 663                   $$ = t;
 664                 }
 665 ;
 666
 667 /* 19.5 Productions from 6: Names  */
 668 name:
 669         simple_name             /* Default rule */
 670 |       qualified_name          /* Default rule */
 671 ;
 672
 673 simple_name:
 674         identifier              /* Default rule */
 675 ;
 676
 677 qualified_name:
 678         name DOT_TK identifier
 679                 { $$ = make_qualified_name ($1, $3, $2.location); }
 680 ;
 681
 682 identifier:
 683         ID_TK
 684 ;
 685
 686 /* 19.6: Production from 7: Packages  */
 687 compilation_unit:
 688                 {$$ = NULL;}
 689 |       package_declaration
 690 |       import_declarations
 691 |       type_declarations
 692 |       package_declaration import_declarations
 693 |       package_declaration type_declarations
 694 |       import_declarations type_declarations
 695 |       package_declaration import_declarations type_declarations
 696 ;
 697
 698 import_declarations:
 699         import_declaration
 700                 {
 701                   $$ = NULL;
 702                 }
 703 |       import_declarations import_declaration
 704                 {
 705                   $$ = NULL;
 706                 }
 707 ;
 708
 709 type_declarations:
 710         type_declaration
 711 |       type_declarations type_declaration
 712 ;
 713
 714 package_declaration:
 715         PACKAGE_TK name SC_TK
 716                 {
 717                   ctxp->package = EXPR_WFL_NODE ($2);
 718                   register_package (ctxp->package);
 719                 }
 720 |       PACKAGE_TK error
 721                 {yyerror ("Missing name"); RECOVER;}
 722 |       PACKAGE_TK name error
 723                 {yyerror ("';' expected"); RECOVER;}
 724 ;
 725
 726 import_declaration:
 727         single_type_import_declaration
 728 |       type_import_on_demand_declaration
 729 ;
 730
 731 single_type_import_declaration:
 732         IMPORT_TK name SC_TK
 733                 {
 734                   tree name = EXPR_WFL_NODE ($2), last_name;
 735                   int   i = IDENTIFIER_LENGTH (name)-1;
 736                   const char *last = &IDENTIFIER_POINTER (name)[i];
 737                   while (last != IDENTIFIER_POINTER (name))
 738                     {
 739                       if (last [0] == '.')
 740                         break;
 741                       last--;
 742                     }
 743                   last_name = get_identifier (++last);
 744                   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
 745                     {
 746                       tree err = find_name_in_single_imports (last_name);
 747                       if (err && err != name)
 748                         parse_error_context
 749                           ($2, "Ambiguous class: `%s' and `%s'",
 750                            IDENTIFIER_POINTER (name),
 751                            IDENTIFIER_POINTER (err));
 752                       else
 753                         REGISTER_IMPORT ($2, last_name);
 754                     }
 755                   else
 756                     REGISTER_IMPORT ($2, last_name);
 757                 }
 758 |       IMPORT_TK error
 759                 {yyerror ("Missing name"); RECOVER;}
 760 |       IMPORT_TK name error
 761                 {yyerror ("';' expected"); RECOVER;}
 762 ;
 763
 764 type_import_on_demand_declaration:
 765         IMPORT_TK name DOT_TK MULT_TK SC_TK
 766                 {
 767                   tree name = EXPR_WFL_NODE ($2);
 768                   tree it;
 769                   /* Search for duplicates. */
 770                   for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
 771                     if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
 772                       break;
 773                   /* Don't import the same thing more than once, just ignore
 774                      duplicates (7.5.2) */
 775                   if (! it)
 776                     {
 777                       read_import_dir ($2);
 778                       ctxp->import_demand_list =
 779                         chainon (ctxp->import_demand_list,
 780                                  build_tree_list ($2, NULL_TREE));
 781                     }
 782                 }
 783 |       IMPORT_TK name DOT_TK error
 784                 {yyerror ("'*' expected"); RECOVER;}
 785 |       IMPORT_TK name DOT_TK MULT_TK error
 786                 {yyerror ("';' expected"); RECOVER;}
 787 ;
 788
 789 type_declaration:
 790         class_declaration
 791                 { end_class_declaration (0); }
 792 |       interface_declaration
 793                 { end_class_declaration (0); }
 794 |       empty_statement
 795 |       error
 796                 {
 797                   YYERROR_NOW;
 798                   yyerror ("Class or interface declaration expected");
 799                 }
 800 ;
 801
 802 /* 19.7 Shortened from the original:
 803    modifiers: modifier | modifiers modifier
 804    modifier: any of public...  */
 805 modifiers:
 806         MODIFIER_TK
 807                 {
 808                   $$ = (1 << $1);
 809                 }
 810 |       modifiers MODIFIER_TK
 811                 {
 812                   int acc = (1 << $2);
 813                   if ($$ & acc)
 814                     parse_error_context
 815                       (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
 816                        java_accstring_lookup (acc));
 817                   else
 818                     {
 819                       $$ |= acc;
 820                     }
 821                 }
 822 ;
 823
 824 /* 19.8.1 Production from $8.1: Class Declaration */
 825 class_declaration:
 826         modifiers CLASS_TK identifier super interfaces
 827                 { create_class ($1, $3, $4, $5); }
 828         class_body
 829                 {;}
 830 |       CLASS_TK identifier super interfaces
 831                 { create_class (0, $2, $3, $4); }
 832         class_body
 833                 {;}
 834 |       modifiers CLASS_TK error
 835                 { yyerror ("Missing class name"); RECOVER; }
 836 |       CLASS_TK error
 837                 { yyerror ("Missing class name"); RECOVER; }
 838 |       CLASS_TK identifier error
 839                 {
 840                   if (!ctxp->class_err) yyerror ("'{' expected");
 841                   DRECOVER(class1);
 842                 }
 843 |       modifiers CLASS_TK identifier error
 844                 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
 845 ;
 846
 847 super:
 848                 { $$ = NULL; }
 849 |       EXTENDS_TK class_type
 850                 { $$ = $2; }
 851 |       EXTENDS_TK class_type error
 852                 {yyerror ("'{' expected"); ctxp->class_err=1;}
 853 |       EXTENDS_TK error
 854                 {yyerror ("Missing super class name"); ctxp->class_err=1;}
 855 ;
 856
 857 interfaces:
 858                 { $$ = NULL_TREE; }
 859 |       IMPLEMENTS_TK interface_type_list
 860                 { $$ = $2; }
 861 |       IMPLEMENTS_TK error
 862                 {
 863                   ctxp->class_err=1;
 864                   yyerror ("Missing interface name");
 865                 }
 866 ;
 867
 868 interface_type_list:
 869         interface_type
 870                 {
 871                   ctxp->interface_number = 1;
 872                   $$ = build_tree_list ($1, NULL_TREE);
 873                 }
 874 |       interface_type_list C_TK interface_type
 875                 {
 876                   ctxp->interface_number++;
 877                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
 878                 }
 879 |       interface_type_list C_TK error
 880                 {yyerror ("Missing interface name"); RECOVER;}
 881 ;
 882
 883 class_body:
 884         OCB_TK CCB_TK
 885                 {
 886                   /* Store the location of the `}' when doing xrefs */
 887                   if (flag_emit_xref)
 888                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 889                       EXPR_WFL_ADD_COL ($2.location, 1);
 890                   $$ = GET_CPC ();
 891                 }
 892 |       OCB_TK class_body_declarations CCB_TK
 893                 {
 894                   /* Store the location of the `}' when doing xrefs */
 895                   if (flag_emit_xref)
 896                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 897                       EXPR_WFL_ADD_COL ($3.location, 1);
 898                   $$ = GET_CPC ();
 899                 }
 900 ;
 901
 902 class_body_declarations:
 903         class_body_declaration
 904 |       class_body_declarations class_body_declaration
 905 ;
 906
 907 class_body_declaration:
 908         class_member_declaration
 909 |       static_initializer
 910 |       constructor_declaration
 911 |       block                   /* Added, JDK1.1, instance initializer */
 912                 {
 913                   if (!IS_EMPTY_STMT ($1))
 914                     {
 915                       TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
 916                       SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
 917                     }
 918                 }
 919 ;
 920
 921 class_member_declaration:
 922         field_declaration
 923 |       method_declaration
 924 |       class_declaration       /* Added, JDK1.1 inner classes */
 925                 { end_class_declaration (1); }
 926 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
 927                 { end_class_declaration (1); }
 928 |       empty_statement
 929 ;
 930
 931 /* 19.8.2 Productions from 8.3: Field Declarations  */
 932 field_declaration:
 933         type variable_declarators SC_TK
 934                 { register_fields (0, $1, $2); }
 935 |       modifiers type variable_declarators SC_TK
 936                 {
 937                   check_modifiers
 938                     ("Illegal modifier `%s' for field declaration",
 939                      $1, FIELD_MODIFIERS);
 940                   check_modifiers_consistency ($1);
 941                   register_fields ($1, $2, $3);
 942                 }
 943 ;
 944
 945 variable_declarators:
 946         /* Should we use build_decl_list () instead ? FIXME */
 947         variable_declarator     /* Default rule */
 948 |       variable_declarators C_TK variable_declarator
 949                 { $$ = chainon ($1, $3); }
 950 |       variable_declarators C_TK error
 951                 {yyerror ("Missing term"); RECOVER;}
 952 ;
 953
 954 variable_declarator:
 955         variable_declarator_id
 956                 { $$ = build_tree_list ($1, NULL_TREE); }
 957 |       variable_declarator_id ASSIGN_TK variable_initializer
 958                 {
 959                   if (java_error_count)
 960                     $3 = NULL_TREE;
 961                   $$ = build_tree_list
 962                     ($1, build_assignment ($2.token, $2.location, $1, $3));
 963                 }
 964 |       variable_declarator_id ASSIGN_TK error
 965                 {
 966                   yyerror ("Missing variable initializer");
 967                   $$ = build_tree_list ($1, NULL_TREE);
 968                   RECOVER;
 969                 }
 970 |       variable_declarator_id ASSIGN_TK variable_initializer error
 971                 {
 972                   yyerror ("';' expected");
 973                   $$ = build_tree_list ($1, NULL_TREE);
 974                   RECOVER;
 975                 }
 976 ;
 977
 978 variable_declarator_id:
 979         identifier
 980 |       variable_declarator_id OSB_TK CSB_TK
 981                 { $$ = build_unresolved_array_type ($1); }
 982 |       identifier error
 983                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
 984 |       variable_declarator_id OSB_TK error
 985                 {
 986                   yyerror ("']' expected");
 987                   DRECOVER(vdi);
 988                 }
 989 |       variable_declarator_id CSB_TK error
 990                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
 991 ;
 992
 993 variable_initializer:
 994         expression
 995 |       array_initializer
 996 ;
 997
 998 /* 19.8.3 Productions from 8.4: Method Declarations  */
 999 method_declaration:
1000         method_header
1001                 {
1002                   current_function_decl = $1;
1003                   if (current_function_decl
1004                       && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1005                     source_start_java_method (current_function_decl);
1006                   else
1007                     current_function_decl = NULL_TREE;
1008                 }
1009         method_body
1010                 { finish_method_declaration ($3); }
1011 |       method_header error
1012                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1013 ;
1014
1015 method_header:
1016         type method_declarator throws
1017                 { $$ = method_header (0, $1, $2, $3); }
1018 |       VOID_TK method_declarator throws
1019                 { $$ = method_header (0, void_type_node, $2, $3); }
1020 |       modifiers type method_declarator throws
1021                 { $$ = method_header ($1, $2, $3, $4); }
1022 |       modifiers VOID_TK method_declarator throws
1023                 { $$ = method_header ($1, void_type_node, $3, $4); }
1024 |       type error
1025                 {
1026                   yyerror ("Invalid method declaration, method name required");
1027                   RECOVER;
1028                 }
1029 |       modifiers type error
1030                 {
1031                   yyerror ("Identifier expected");
1032                   RECOVER;
1033                 }
1034 |       VOID_TK error
1035                 {
1036                   yyerror ("Identifier expected");
1037                   RECOVER;
1038                 }
1039 |       modifiers VOID_TK error
1040                 {
1041                   yyerror ("Identifier expected");
1042                   RECOVER;
1043                 }
1044 |       modifiers error
1045                 {
1046                   yyerror ("Invalid method declaration, return type required");
1047                   RECOVER;
1048                 }
1049 ;
1050
1051 method_declarator:
1052         identifier OP_TK CP_TK
1053                 {
1054                   ctxp->formal_parameter_number = 0;
1055                   $$ = method_declarator ($1, NULL_TREE);
1056                 }
1057 |       identifier OP_TK formal_parameter_list CP_TK
1058                 { $$ = method_declarator ($1, $3); }
1059 |       method_declarator OSB_TK CSB_TK
1060                 {
1061                   EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1062                   TREE_PURPOSE ($1) =
1063                     build_unresolved_array_type (TREE_PURPOSE ($1));
1064                   parse_warning_context
1065                     (wfl_operator,
1066                      "Discouraged form of returned type specification");
1067                 }
1068 |       identifier OP_TK error
1069                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1070 |       method_declarator OSB_TK error
1071                 {yyerror ("']' expected"); RECOVER;}
1072 ;
1073
1074 formal_parameter_list:
1075         formal_parameter
1076                 {
1077                   ctxp->formal_parameter_number = 1;
1078                 }
1079 |       formal_parameter_list C_TK formal_parameter
1080                 {
1081                   ctxp->formal_parameter_number += 1;
1082                   $$ = chainon ($1, $3);
1083                 }
1084 |       formal_parameter_list C_TK error
1085                 { yyerror ("Missing formal parameter term"); RECOVER; }
1086 ;
1087
1088 formal_parameter:
1089         type variable_declarator_id
1090                 {
1091                   $$ = build_tree_list ($2, $1);
1092                 }
1093 |       final type variable_declarator_id /* Added, JDK1.1 final parms */
1094                 {
1095                   $$ = build_tree_list ($3, $2);
1096                   ARG_FINAL_P ($$) = 1;
1097                 }
1098 |       type error
1099                 {
1100                   yyerror ("Missing identifier"); RECOVER;
1101                   $$ = NULL_TREE;
1102                 }
1103 |       final type error
1104                 {
1105                   yyerror ("Missing identifier"); RECOVER;
1106                   $$ = NULL_TREE;
1107                 }
1108 ;
1109
1110 final:
1111         modifiers
1112                 {
1113                   check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1114                                    $1, ACC_FINAL);
1115                   if ($1 != ACC_FINAL)
1116                     MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1117                 }
1118 ;
1119
1120 throws:
1121                 { $$ = NULL_TREE; }
1122 |       THROWS_TK class_type_list
1123                 { $$ = $2; }
1124 |       THROWS_TK error
1125                 {yyerror ("Missing class type term"); RECOVER;}
1126 ;
1127
1128 class_type_list:
1129         class_type
1130                 { $$ = build_tree_list ($1, $1); }
1131 |       class_type_list C_TK class_type
1132                 { $$ = tree_cons ($3, $3, $1); }
1133 |       class_type_list C_TK error
1134                 {yyerror ("Missing class type term"); RECOVER;}
1135 ;
1136
1137 method_body:
1138         block
1139 |       SC_TK { $$ = NULL_TREE; }
1140 ;
1141
1142 /* 19.8.4 Productions from 8.5: Static Initializers  */
1143 static_initializer:
1144         static block
1145                 {
1146                   TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1147                   SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1148                   current_static_block = NULL_TREE;
1149                 }
1150 ;
1151
1152 static:                         /* Test lval.sub_token here */
1153         modifiers
1154                 {
1155                   check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1156                   /* Can't have a static initializer in an innerclass */
1157                   if ($1 | ACC_STATIC &&
1158                       GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1159                     parse_error_context
1160                       (MODIFIER_WFL (STATIC_TK),
1161                        "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1162                        IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1163                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1164                 }
1165 ;
1166
1167 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1168 constructor_declaration:
1169         constructor_header
1170                 {
1171                   current_function_decl = $1;
1172                   source_start_java_method (current_function_decl);
1173                 }
1174         constructor_body
1175                 { finish_method_declaration ($3); }
1176 ;
1177
1178 constructor_header:
1179         constructor_declarator throws
1180                 { $$ = method_header (0, NULL_TREE, $1, $2); }
1181 |       modifiers constructor_declarator throws
1182                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1183 ;
1184
1185 constructor_declarator:
1186         simple_name OP_TK CP_TK
1187                 {
1188                   ctxp->formal_parameter_number = 0;
1189                   $$ = method_declarator ($1, NULL_TREE);
1190                 }
1191 |       simple_name OP_TK formal_parameter_list CP_TK
1192                 { $$ = method_declarator ($1, $3); }
1193 ;
1194
1195 constructor_body:
1196         /* Unlike regular method, we always need a complete (empty)
1197            body so we can safely perform all the required code
1198            addition (super invocation and field initialization) */
1199         block_begin constructor_block_end
1200                 {
1201                   BLOCK_EXPR_BODY ($2) = build_java_empty_stmt ();
1202                   $$ = $2;
1203                 }
1204 |       block_begin explicit_constructor_invocation constructor_block_end
1205                 { $$ = $3; }
1206 |       block_begin block_statements constructor_block_end
1207                 { $$ = $3; }
1208 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1209                 { $$ = $4; }
1210 ;
1211
1212 constructor_block_end:
1213         block_end
1214 ;
1215
1216 /* Error recovery for that rule moved down expression_statement: rule.  */
1217 explicit_constructor_invocation:
1218         this_or_super OP_TK CP_TK SC_TK
1219                 {
1220                   $$ = build_method_invocation ($1, NULL_TREE);
1221                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1222                   $$ = java_method_add_stmt (current_function_decl, $$);
1223                 }
1224 |       this_or_super OP_TK argument_list CP_TK SC_TK
1225                 {
1226                   $$ = build_method_invocation ($1, $3);
1227                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1228                   $$ = java_method_add_stmt (current_function_decl, $$);
1229                 }
1230         /* Added, JDK1.1 inner classes. Modified because the rule
1231            'primary' couldn't work.  */
1232 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1233                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1234 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1235                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1236 ;
1237
1238 this_or_super:                  /* Added, simplifies error diagnostics */
1239         THIS_TK
1240                 {
1241                   tree wfl = build_wfl_node (this_identifier_node);
1242                   EXPR_WFL_LINECOL (wfl) = $1.location;
1243                   $$ = wfl;
1244                 }
1245 |       SUPER_TK
1246                 {
1247                   tree wfl = build_wfl_node (super_identifier_node);
1248                   EXPR_WFL_LINECOL (wfl) = $1.location;
1249                   $$ = wfl;
1250                 }
1251 ;
1252
1253 /* 19.9 Productions from 9: Interfaces  */
1254 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1255 interface_declaration:
1256         INTERFACE_TK identifier
1257                 { create_interface (0, $2, NULL_TREE); }
1258         interface_body
1259                 { ; }
1260 |       modifiers INTERFACE_TK identifier
1261                 { create_interface ($1, $3, NULL_TREE); }
1262         interface_body
1263                 { ; }
1264 |       INTERFACE_TK identifier extends_interfaces
1265                 { create_interface (0, $2, $3); }
1266         interface_body
1267                 { ; }
1268 |       modifiers INTERFACE_TK identifier extends_interfaces
1269                 { create_interface ($1, $3, $4); }
1270         interface_body
1271                 { ; }
1272 |       INTERFACE_TK identifier error
1273                 { yyerror ("'{' expected"); RECOVER; }
1274 |       modifiers INTERFACE_TK identifier error
1275                 { yyerror ("'{' expected"); RECOVER; }
1276 ;
1277
1278 extends_interfaces:
1279         EXTENDS_TK interface_type
1280                 {
1281                   ctxp->interface_number = 1;
1282                   $$ = build_tree_list ($2, NULL_TREE);
1283                 }
1284 |       extends_interfaces C_TK interface_type
1285                 {
1286                   ctxp->interface_number++;
1287                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1288                 }
1289 |       EXTENDS_TK error
1290                 {yyerror ("Invalid interface type"); RECOVER;}
1291 |       extends_interfaces C_TK error
1292                 {yyerror ("Missing term"); RECOVER;}
1293 ;
1294
1295 interface_body:
1296         OCB_TK CCB_TK
1297                 { $$ = NULL_TREE; }
1298 |       OCB_TK interface_member_declarations CCB_TK
1299                 { $$ = NULL_TREE; }
1300 ;
1301
1302 interface_member_declarations:
1303         interface_member_declaration
1304 |       interface_member_declarations interface_member_declaration
1305 ;
1306
1307 interface_member_declaration:
1308         constant_declaration
1309 |       abstract_method_declaration
1310 |       class_declaration       /* Added, JDK1.1 inner classes */
1311                 { end_class_declaration (1); }
1312 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
1313                 { end_class_declaration (1); }
1314 ;
1315
1316 constant_declaration:
1317         field_declaration
1318 ;
1319
1320 abstract_method_declaration:
1321         method_header SC_TK
1322                 {
1323                   check_abstract_method_header ($1);
1324                   current_function_decl = NULL_TREE; /* FIXME ? */
1325                 }
1326 |       method_header error
1327                 {yyerror ("';' expected"); RECOVER;}
1328 ;
1329
1330 /* 19.10 Productions from 10: Arrays  */
1331 array_initializer:
1332         OCB_TK CCB_TK
1333                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1334 |       OCB_TK C_TK CCB_TK
1335                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1336 |       OCB_TK variable_initializers CCB_TK
1337                 { $$ = build_new_array_init ($1.location, $2); }
1338 |       OCB_TK variable_initializers C_TK CCB_TK
1339                 { $$ = build_new_array_init ($1.location, $2); }
1340 ;
1341
1342 variable_initializers:
1343         variable_initializer
1344                 {
1345                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1346                                   $1, NULL_TREE);
1347                 }
1348 |       variable_initializers C_TK variable_initializer
1349                 {
1350                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1351                 }
1352 |       variable_initializers C_TK error
1353                 {yyerror ("Missing term"); RECOVER;}
1354 ;
1355
1356 /* 19.11 Production from 14: Blocks and Statements  */
1357 block:
1358         block_begin block_end
1359                 { $$ = $2; }
1360 |       block_begin block_statements block_end
1361                 { $$ = $3; }
1362 ;
1363
1364 block_begin:
1365         OCB_TK
1366                 { enter_block (); }
1367 ;
1368
1369 block_end:
1370         CCB_TK
1371                 {
1372                   maybe_absorb_scoping_blocks ();
1373                   /* Store the location of the `}' when doing xrefs */
1374                   if (current_function_decl && flag_emit_xref)
1375                     DECL_END_SOURCE_LINE (current_function_decl) =
1376                       EXPR_WFL_ADD_COL ($1.location, 1);
1377                   $$ = exit_block ();
1378                   if (!BLOCK_SUBBLOCKS ($$))
1379                     BLOCK_SUBBLOCKS ($$) = build_java_empty_stmt ();
1380                 }
1381 ;
1382
1383 block_statements:
1384         block_statement
1385 |       block_statements block_statement
1386 ;
1387
1388 block_statement:
1389         local_variable_declaration_statement
1390 |       statement
1391                 { java_method_add_stmt (current_function_decl, $1); }
1392 |       class_declaration       /* Added, JDK1.1 local classes */
1393                 {
1394                   LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1395                   end_class_declaration (1);
1396                 }
1397 ;
1398
1399 local_variable_declaration_statement:
1400         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1401 ;
1402
1403 local_variable_declaration:
1404         type variable_declarators
1405                 { declare_local_variables (0, $1, $2); }
1406 |       final type variable_declarators /* Added, JDK1.1 final locals */
1407                 { declare_local_variables ($1, $2, $3); }
1408 ;
1409
1410 statement:
1411         statement_without_trailing_substatement
1412 |       labeled_statement
1413 |       if_then_statement
1414 |       if_then_else_statement
1415 |       while_statement
1416 |       for_statement
1417                 { $$ = exit_block (); }
1418 ;
1419
1420 statement_nsi:
1421         statement_without_trailing_substatement
1422 |       labeled_statement_nsi
1423 |       if_then_else_statement_nsi
1424 |       while_statement_nsi
1425 |       for_statement_nsi
1426                 { $$ = exit_block (); }
1427 ;
1428
1429 statement_without_trailing_substatement:
1430         block
1431 |       empty_statement
1432 |       expression_statement
1433 |       switch_statement
1434 |       do_statement
1435 |       break_statement
1436 |       continue_statement
1437 |       return_statement
1438 |       synchronized_statement
1439 |       throw_statement
1440 |       try_statement
1441 |       assert_statement
1442 ;
1443
1444 empty_statement:
1445         SC_TK
1446                 {
1447                   if (flag_extraneous_semicolon
1448                       && ! current_static_block
1449                       && (! current_function_decl ||
1450                           /* Verify we're not in a inner class declaration */
1451                           (GET_CPC () != TYPE_NAME
1452                            (DECL_CONTEXT (current_function_decl)))))
1453
1454                     {
1455                       EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1456                       parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1457                     }
1458                   $$ = build_java_empty_stmt ();
1459                 }
1460 ;
1461
1462 label_decl:
1463         identifier REL_CL_TK
1464                 {
1465                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1466                                             EXPR_WFL_NODE ($1));
1467                   pushlevel (2);
1468                   push_labeled_block ($$);
1469                   PUSH_LABELED_BLOCK ($$);
1470                 }
1471 ;
1472
1473 labeled_statement:
1474         label_decl statement
1475                 { $$ = finish_labeled_statement ($1, $2); }
1476 |       identifier error
1477                 {yyerror ("':' expected"); RECOVER;}
1478 ;
1479
1480 labeled_statement_nsi:
1481         label_decl statement_nsi
1482                 { $$ = finish_labeled_statement ($1, $2); }
1483 ;
1484
1485 /* We concentrate here a bunch of error handling rules that we couldn't write
1486    earlier, because expression_statement catches a missing ';'.  */
1487 expression_statement:
1488         statement_expression SC_TK
1489                 {
1490                   /* We have a statement. Generate a WFL around it so
1491                      we can debug it */
1492                   $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1493                   /* We know we have a statement, so set the debug
1494                      info to be eventually generate here. */
1495                   $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1496                 }
1497 |       error SC_TK
1498                 {
1499                   YYNOT_TWICE yyerror ("Invalid expression statement");
1500                   DRECOVER (expr_stmt);
1501                 }
1502 |       error OCB_TK
1503                 {
1504                   YYNOT_TWICE yyerror ("Invalid expression statement");
1505                   DRECOVER (expr_stmt);
1506                 }
1507 |       error CCB_TK
1508                 {
1509                   YYNOT_TWICE yyerror ("Invalid expression statement");
1510                   DRECOVER (expr_stmt);
1511                 }
1512 |       this_or_super OP_TK error
1513                 {yyerror ("')' expected"); RECOVER;}
1514 |       this_or_super OP_TK CP_TK error
1515                 {
1516                   parse_ctor_invocation_error ();
1517                   RECOVER;
1518                 }
1519 |       this_or_super OP_TK argument_list error
1520                 {yyerror ("')' expected"); RECOVER;}
1521 |       this_or_super OP_TK argument_list CP_TK error
1522                 {
1523                   parse_ctor_invocation_error ();
1524                   RECOVER;
1525                 }
1526 |       name DOT_TK SUPER_TK error
1527                 {yyerror ("'(' expected"); RECOVER;}
1528 |       name DOT_TK SUPER_TK OP_TK error
1529                 {yyerror ("')' expected"); RECOVER;}
1530 |       name DOT_TK SUPER_TK OP_TK argument_list error
1531                 {yyerror ("')' expected"); RECOVER;}
1532 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1533                 {yyerror ("';' expected"); RECOVER;}
1534 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1535                 {yyerror ("';' expected"); RECOVER;}
1536 ;
1537
1538 statement_expression:
1539         assignment
1540 |       pre_increment_expression
1541 |       pre_decrement_expression
1542 |       post_increment_expression
1543 |       post_decrement_expression
1544 |       method_invocation
1545 |       class_instance_creation_expression
1546 ;
1547
1548 if_then_statement:
1549         IF_TK OP_TK expression CP_TK statement
1550                 {
1551                   $$ = build_if_else_statement ($2.location, $3,
1552                                                 $5, NULL_TREE);
1553                 }
1554 |       IF_TK error
1555                 {yyerror ("'(' expected"); RECOVER;}
1556 |       IF_TK OP_TK error
1557                 {yyerror ("Missing term"); RECOVER;}
1558 |       IF_TK OP_TK expression error
1559                 {yyerror ("')' expected"); RECOVER;}
1560 ;
1561
1562 if_then_else_statement:
1563         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1564                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1565 ;
1566
1567 if_then_else_statement_nsi:
1568         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1569                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1570 ;
1571
1572 switch_statement:
1573         switch_expression
1574                 {
1575                   enter_block ();
1576                 }
1577         switch_block
1578                 {
1579                   /* Make into "proper list" of COMPOUND_EXPRs.
1580                      I.e. make the last statement also have its own
1581                      COMPOUND_EXPR. */
1582                   maybe_absorb_scoping_blocks ();
1583                   TREE_OPERAND ($1, 1) = exit_block ();
1584                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1585                 }
1586 ;
1587
1588 switch_expression:
1589         SWITCH_TK OP_TK expression CP_TK
1590                 {
1591                   $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE, NULL_TREE);
1592                   EXPR_WFL_LINECOL ($$) = $2.location;
1593                 }
1594 |       SWITCH_TK error
1595                 {yyerror ("'(' expected"); RECOVER;}
1596 |       SWITCH_TK OP_TK error
1597                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1598 |       SWITCH_TK OP_TK expression CP_TK error
1599                 {yyerror ("'{' expected"); RECOVER;}
1600 ;
1601
1602 /* Default assignment is there to avoid type node on switch_block
1603    node. */
1604
1605 switch_block:
1606         OCB_TK CCB_TK
1607                 { $$ = NULL_TREE; }
1608 |       OCB_TK switch_labels CCB_TK
1609                 { $$ = NULL_TREE; }
1610 |       OCB_TK switch_block_statement_groups CCB_TK
1611                 { $$ = NULL_TREE; }
1612 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1613                 { $$ = NULL_TREE; }
1614 ;
1615
1616 switch_block_statement_groups:
1617         switch_block_statement_group
1618 |       switch_block_statement_groups switch_block_statement_group
1619 ;
1620
1621 switch_block_statement_group:
1622         switch_labels block_statements
1623 ;
1624
1625 switch_labels:
1626         switch_label
1627 |       switch_labels switch_label
1628 ;
1629
1630 switch_label:
1631         CASE_TK constant_expression REL_CL_TK
1632                 {
1633                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1634                   EXPR_WFL_LINECOL (lab) = $1.location;
1635                   java_method_add_stmt (current_function_decl, lab);
1636                 }
1637 |       DEFAULT_TK REL_CL_TK
1638                 {
1639                   tree lab = make_node (DEFAULT_EXPR);
1640                   EXPR_WFL_LINECOL (lab) = $1.location;
1641                   java_method_add_stmt (current_function_decl, lab);
1642                 }
1643 |       CASE_TK error
1644                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1645 |       CASE_TK constant_expression error
1646                 {yyerror ("':' expected"); RECOVER;}
1647 |       DEFAULT_TK error
1648                 {yyerror ("':' expected"); RECOVER;}
1649 ;
1650
1651 while_expression:
1652         WHILE_TK OP_TK expression CP_TK
1653                 {
1654                   tree body = build_loop_body ($2.location, $3, 0);
1655                   $$ = build_new_loop (body);
1656                 }
1657 ;
1658
1659 while_statement:
1660         while_expression statement
1661                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1662 |       WHILE_TK error
1663                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1664 |       WHILE_TK OP_TK error
1665                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1666 |       WHILE_TK OP_TK expression error
1667                 {yyerror ("')' expected"); RECOVER;}
1668 ;
1669
1670 while_statement_nsi:
1671         while_expression statement_nsi
1672                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1673 ;
1674
1675 do_statement_begin:
1676         DO_TK
1677                 {
1678                   tree body = build_loop_body (0, NULL_TREE, 1);
1679                   $$ = build_new_loop (body);
1680                 }
1681         /* Need error handing here. FIXME */
1682 ;
1683
1684 do_statement:
1685         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1686                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1687 ;
1688
1689 for_statement:
1690         for_begin SC_TK expression SC_TK for_update CP_TK statement
1691                 {
1692                   if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1693                     $3 = build_wfl_node ($3);
1694                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1695                 }
1696 |       for_begin SC_TK SC_TK for_update CP_TK statement
1697                 {
1698                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1699                   /* We have not condition, so we get rid of the EXIT_EXPR */
1700                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1701                     build_java_empty_stmt ();
1702                 }
1703 |       for_begin SC_TK error
1704                 {yyerror ("Invalid control expression"); RECOVER;}
1705 |       for_begin SC_TK expression SC_TK error
1706                 {yyerror ("Invalid update expression"); RECOVER;}
1707 |       for_begin SC_TK SC_TK error
1708                 {yyerror ("Invalid update expression"); RECOVER;}
1709 ;
1710
1711 for_statement_nsi:
1712         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1713                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1714 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1715                 {
1716                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1717                   /* We have not condition, so we get rid of the EXIT_EXPR */
1718                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1719                     build_java_empty_stmt ();
1720                 }
1721 ;
1722
1723 for_header:
1724         FOR_TK OP_TK
1725                 {
1726                   /* This scope defined for local variable that may be
1727                      defined within the scope of the for loop */
1728                   enter_block ();
1729                 }
1730 |       FOR_TK error
1731                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1732 |       FOR_TK OP_TK error
1733                 {yyerror ("Invalid init statement"); RECOVER;}
1734 ;
1735
1736 for_begin:
1737         for_header for_init
1738                 {
1739                   /* We now declare the loop body. The loop is
1740                      declared as a for loop. */
1741                   tree body = build_loop_body (0, NULL_TREE, 0);
1742                   $$ =  build_new_loop (body);
1743                   FOR_LOOP_P ($$) = 1;
1744                   /* The loop is added to the current block the for
1745                      statement is defined within */
1746                   java_method_add_stmt (current_function_decl, $$);
1747                 }
1748 ;
1749 for_init:                       /* Can be empty */
1750                 { $$ = build_java_empty_stmt (); }
1751 |       statement_expression_list
1752                 {
1753                   /* Init statement recorded within the previously
1754                      defined block scope */
1755                   $$ = java_method_add_stmt (current_function_decl, $1);
1756                 }
1757 |       local_variable_declaration
1758                 {
1759                   /* Local variable are recorded within the previously
1760                      defined block scope */
1761                   $$ = NULL_TREE;
1762                 }
1763 |       statement_expression_list error
1764                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1765 ;
1766
1767 for_update:                     /* Can be empty */
1768                 {$$ = build_java_empty_stmt ();}
1769 |       statement_expression_list
1770                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1771 ;
1772
1773 statement_expression_list:
1774         statement_expression
1775                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1776 |       statement_expression_list C_TK statement_expression
1777                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1778 |       statement_expression_list C_TK error
1779                 {yyerror ("Missing term"); RECOVER;}
1780 ;
1781
1782 break_statement:
1783         BREAK_TK SC_TK
1784                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1785 |       BREAK_TK identifier SC_TK
1786                 { $$ = build_bc_statement ($1.location, 1, $2); }
1787 |       BREAK_TK error
1788                 {yyerror ("Missing term"); RECOVER;}
1789 |       BREAK_TK identifier error
1790                 {yyerror ("';' expected"); RECOVER;}
1791 ;
1792
1793 continue_statement:
1794         CONTINUE_TK SC_TK
1795                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1796 |       CONTINUE_TK identifier SC_TK
1797                 { $$ = build_bc_statement ($1.location, 0, $2); }
1798 |       CONTINUE_TK error
1799                 {yyerror ("Missing term"); RECOVER;}
1800 |       CONTINUE_TK identifier error
1801                 {yyerror ("';' expected"); RECOVER;}
1802 ;
1803
1804 return_statement:
1805         RETURN_TK SC_TK
1806                 { $$ = build_return ($1.location, NULL_TREE); }
1807 |       RETURN_TK expression SC_TK
1808                 { $$ = build_return ($1.location, $2); }
1809 |       RETURN_TK error
1810                 {yyerror ("Missing term"); RECOVER;}
1811 |       RETURN_TK expression error
1812                 {yyerror ("';' expected"); RECOVER;}
1813 ;
1814
1815 throw_statement:
1816         THROW_TK expression SC_TK
1817                 {
1818                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1819                   EXPR_WFL_LINECOL ($$) = $1.location;
1820                 }
1821 |       THROW_TK error
1822                 {yyerror ("Missing term"); RECOVER;}
1823 |       THROW_TK expression error
1824                 {yyerror ("';' expected"); RECOVER;}
1825 ;
1826
1827 assert_statement:
1828         ASSERT_TK expression REL_CL_TK expression SC_TK
1829                 {
1830                   $$ = build_assertion ($1.location, $2, $4);
1831                 }
1832 |       ASSERT_TK expression SC_TK
1833                 {
1834                   $$ = build_assertion ($1.location, $2, NULL_TREE);
1835                 }
1836 |       ASSERT_TK error
1837                 {yyerror ("Missing term"); RECOVER;}
1838 |       ASSERT_TK expression error
1839                 {yyerror ("';' expected"); RECOVER;}
1840 ;
1841
1842 synchronized_statement:
1843         synchronized OP_TK expression CP_TK block
1844                 {
1845                   $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1846                   EXPR_WFL_LINECOL ($$) =
1847                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1848                 }
1849 |       synchronized OP_TK expression CP_TK error
1850                 {yyerror ("'{' expected"); RECOVER;}
1851 |       synchronized error
1852                 {yyerror ("'(' expected"); RECOVER;}
1853 |       synchronized OP_TK error CP_TK
1854                 {yyerror ("Missing term"); RECOVER;}
1855 |       synchronized OP_TK error
1856                 {yyerror ("Missing term"); RECOVER;}
1857 ;
1858
1859 synchronized:
1860         modifiers
1861                 {
1862                   check_modifiers (
1863              "Illegal modifier `%s'. Only `synchronized' was expected here",
1864                                    $1, ACC_SYNCHRONIZED);
1865                   if ($1 != ACC_SYNCHRONIZED)
1866                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1867                       build_wfl_node (NULL_TREE);
1868                 }
1869 ;
1870
1871 try_statement:
1872         TRY_TK block catches
1873                 { $$ = build_try_statement ($1.location, $2, $3); }
1874 |       TRY_TK block finally
1875                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1876 |       TRY_TK block catches finally
1877                 { $$ = build_try_finally_statement
1878                     ($1.location, build_try_statement ($1.location,
1879                                                        $2, $3), $4);
1880                 }
1881 |       TRY_TK error
1882                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1883 ;
1884
1885 catches:
1886         catch_clause
1887 |       catches catch_clause
1888                 {
1889                   TREE_CHAIN ($2) = $1;
1890                   $$ = $2;
1891                 }
1892 ;
1893
1894 catch_clause:
1895         catch_clause_parameter block
1896                 {
1897                   java_method_add_stmt (current_function_decl, $2);
1898                   exit_block ();
1899                   $$ = $1;
1900                 }
1901 ;
1902
1903 catch_clause_parameter:
1904         CATCH_TK OP_TK formal_parameter CP_TK
1905                 {
1906                   /* We add a block to define a scope for
1907                      formal_parameter (CCBP). The formal parameter is
1908                      declared initialized by the appropriate function
1909                      call */
1910                   tree ccpb;
1911                   tree init;
1912                   if ($3)
1913                     {
1914                       ccpb = enter_block ();
1915                       init = build_assignment
1916                         (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1917                          build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1918                       declare_local_variables (0, TREE_VALUE ($3),
1919                                                build_tree_list
1920                                                (TREE_PURPOSE ($3), init));
1921                       $$ = build1 (JAVA_CATCH_EXPR, NULL_TREE, ccpb);
1922                       EXPR_WFL_LINECOL ($$) = $1.location;
1923                     }
1924                   else
1925                     {
1926                       $$ = error_mark_node;
1927                     }
1928                 }
1929 |       CATCH_TK error
1930                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1931 |       CATCH_TK OP_TK error
1932                 {
1933                   yyerror ("Missing term or ')' expected");
1934                   RECOVER; $$ = NULL_TREE;
1935                 }
1936 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1937                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1938 ;
1939
1940 finally:
1941         FINALLY_TK block
1942                 { $$ = $2; }
1943 |       FINALLY_TK error
1944                 {yyerror ("'{' expected"); RECOVER; }
1945 ;
1946
1947 /* 19.12 Production from 15: Expressions  */
1948 primary:
1949         primary_no_new_array
1950 |       array_creation_expression
1951 ;
1952
1953 primary_no_new_array:
1954         literal
1955 |       THIS_TK
1956                 { $$ = build_this ($1.location); }
1957 |       OP_TK expression CP_TK
1958                 {$$ = $2;}
1959 |       class_instance_creation_expression
1960 |       field_access
1961 |       method_invocation
1962 |       array_access
1963 |       type_literals
1964         /* Added, JDK1.1 inner classes. Documentation is wrong
1965            refering to a 'ClassName' (class_name) rule that doesn't
1966            exist. Used name: instead.  */
1967 |       name DOT_TK THIS_TK
1968                 {
1969                   tree wfl = build_wfl_node (this_identifier_node);
1970                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1971                 }
1972 |       OP_TK expression error
1973                 {yyerror ("')' expected"); RECOVER;}
1974 |       name DOT_TK error
1975                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1976 |       primitive_type DOT_TK error
1977                 {yyerror ("'class' expected" ); RECOVER;}
1978 |       VOID_TK DOT_TK error
1979                 {yyerror ("'class' expected" ); RECOVER;}
1980 ;
1981
1982 type_literals:
1983         name DOT_TK CLASS_TK
1984                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1985 |       array_type DOT_TK CLASS_TK
1986                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1987 |       primitive_type DOT_TK CLASS_TK
1988                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1989 |       VOID_TK DOT_TK CLASS_TK
1990                 {
1991                    $$ = build_incomplete_class_ref ($2.location,
1992                                                    void_type_node);
1993                 }
1994 ;
1995
1996 class_instance_creation_expression:
1997         NEW_TK class_type OP_TK argument_list CP_TK
1998                 { $$ = build_new_invocation ($2, $4); }
1999 |       NEW_TK class_type OP_TK CP_TK
2000                 { $$ = build_new_invocation ($2, NULL_TREE); }
2001 |       anonymous_class_creation
2002         /* Added, JDK1.1 inner classes, modified to use name or
2003            primary instead of primary solely which couldn't work in
2004            all situations.  */
2005 |       something_dot_new identifier OP_TK CP_TK
2006                 {
2007                   tree ctor = build_new_invocation ($2, NULL_TREE);
2008                   $$ = make_qualified_primary ($1, ctor,
2009                                                EXPR_WFL_LINECOL ($1));
2010                 }
2011 |       something_dot_new identifier OP_TK CP_TK class_body
2012 |       something_dot_new identifier OP_TK argument_list CP_TK
2013                 {
2014                   tree ctor = build_new_invocation ($2, $4);
2015                   $$ = make_qualified_primary ($1, ctor,
2016                                                EXPR_WFL_LINECOL ($1));
2017                 }
2018 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2019 |       NEW_TK error SC_TK
2020                 {yyerror ("'(' expected"); DRECOVER(new_1);}
2021 |       NEW_TK class_type error
2022                 {yyerror ("'(' expected"); RECOVER;}
2023 |       NEW_TK class_type OP_TK error
2024                 {yyerror ("')' or term expected"); RECOVER;}
2025 |       NEW_TK class_type OP_TK argument_list error
2026                 {yyerror ("')' expected"); RECOVER;}
2027 |       something_dot_new error
2028                 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2029 |       something_dot_new identifier error
2030                 {yyerror ("'(' expected"); RECOVER;}
2031 ;
2032
2033 /* Created after JDK1.1 rules originally added to
2034    class_instance_creation_expression, but modified to use
2035    'class_type' instead of 'TypeName' (type_name) which is mentioned
2036    in the documentation but doesn't exist. */
2037
2038 anonymous_class_creation:
2039         NEW_TK class_type OP_TK argument_list CP_TK
2040                 { create_anonymous_class ($1.location, $2); }
2041         class_body
2042                 {
2043                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2044                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2045
2046                   end_class_declaration (1);
2047
2048                   /* Now we can craft the new expression */
2049                   $$ = build_new_invocation (id, $4);
2050
2051                   /* Note that we can't possibly be here if
2052                      `class_type' is an interface (in which case the
2053                      anonymous class extends Object and implements
2054                      `class_type', hence its constructor can't have
2055                      arguments.) */
2056
2057                   /* Otherwise, the innerclass must feature a
2058                      constructor matching `argument_list'. Anonymous
2059                      classes are a bit special: it's impossible to
2060                      define constructor for them, hence constructors
2061                      must be generated following the hints provided by
2062                      the `new' expression. Whether a super constructor
2063                      of that nature exists or not is to be verified
2064                      later on in verify_constructor_super.
2065
2066                      It's during the expansion of a `new' statement
2067                      refering to an anonymous class that a ctor will
2068                      be generated for the anonymous class, with the
2069                      right arguments. */
2070
2071                 }
2072 |       NEW_TK class_type OP_TK CP_TK
2073                 { create_anonymous_class ($1.location, $2); }
2074         class_body
2075                 {
2076                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2077                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2078
2079                   end_class_declaration (1);
2080
2081                   /* Now we can craft the new expression. The
2082                      statement doesn't need to be remember so that a
2083                      constructor can be generated, since its signature
2084                      is already known. */
2085                   $$ = build_new_invocation (id, NULL_TREE);
2086                 }
2087 ;
2088
2089 something_dot_new:              /* Added, not part of the specs. */
2090         name DOT_TK NEW_TK
2091                 { $$ = $1; }
2092 |       primary DOT_TK NEW_TK
2093                 { $$ = $1; }
2094 ;
2095
2096 argument_list:
2097         expression
2098                 {
2099                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2100                   ctxp->formal_parameter_number = 1;
2101                 }
2102 |       argument_list C_TK expression
2103                 {
2104                   ctxp->formal_parameter_number += 1;
2105                   $$ = tree_cons (NULL_TREE, $3, $1);
2106                 }
2107 |       argument_list C_TK error
2108                 {yyerror ("Missing term"); RECOVER;}
2109 ;
2110
2111 array_creation_expression:
2112         NEW_TK primitive_type dim_exprs
2113                 { $$ = build_newarray_node ($2, $3, 0); }
2114 |       NEW_TK class_or_interface_type dim_exprs
2115                 { $$ = build_newarray_node ($2, $3, 0); }
2116 |       NEW_TK primitive_type dim_exprs dims
2117                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2118 |       NEW_TK class_or_interface_type dim_exprs dims
2119                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2120         /* Added, JDK1.1 anonymous array. Initial documentation rule
2121            modified */
2122 |       NEW_TK class_or_interface_type dims array_initializer
2123                 {
2124                   char *sig;
2125                   int osb = pop_current_osb (ctxp);
2126                   while (osb--)
2127                     obstack_grow (&temporary_obstack, "[]", 2);
2128                   obstack_1grow (&temporary_obstack, '\0');
2129                   sig = obstack_finish (&temporary_obstack);
2130                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2131                               $2, get_identifier (sig), $4);
2132                 }
2133 |       NEW_TK primitive_type dims array_initializer
2134                 {
2135                   int osb = pop_current_osb (ctxp);
2136                   tree type = $2;
2137                   while (osb--)
2138                     type = build_java_array_type (type, -1);
2139                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2140                               build_pointer_type (type), NULL_TREE, $4);
2141                 }
2142 |       NEW_TK error CSB_TK
2143                 {yyerror ("'[' expected"); DRECOVER ("]");}
2144 |       NEW_TK error OSB_TK
2145                 {yyerror ("']' expected"); RECOVER;}
2146 ;
2147
2148 dim_exprs:
2149         dim_expr
2150                 { $$ = build_tree_list (NULL_TREE, $1); }
2151 |       dim_exprs dim_expr
2152                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2153 ;
2154
2155 dim_expr:
2156         OSB_TK expression CSB_TK
2157                 {
2158                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2159                     {
2160                       $2 = build_wfl_node ($2);
2161                       TREE_TYPE ($2) = NULL_TREE;
2162                     }
2163                   EXPR_WFL_LINECOL ($2) = $1.location;
2164                   $$ = $2;
2165                 }
2166 |       OSB_TK expression error
2167                 {yyerror ("']' expected"); RECOVER;}
2168 |       OSB_TK error
2169                 {
2170                   yyerror ("Missing term");
2171                   yyerror ("']' expected");
2172                   RECOVER;
2173                 }
2174 ;
2175
2176 dims:
2177         OSB_TK CSB_TK
2178                 {
2179                   int allocate = 0;
2180                   /* If not initialized, allocate memory for the osb
2181                      numbers stack */
2182                   if (!ctxp->osb_limit)
2183                     {
2184                       allocate = ctxp->osb_limit = 32;
2185                       ctxp->osb_depth = -1;
2186                     }
2187                   /* If capacity overflown, reallocate a bigger chunk */
2188                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2189                     allocate = ctxp->osb_limit << 1;
2190
2191                   if (allocate)
2192                     {
2193                       allocate *= sizeof (int);
2194                       if (ctxp->osb_number)
2195                         ctxp->osb_number = xrealloc (ctxp->osb_number,
2196                                                      allocate);
2197                       else
2198                         ctxp->osb_number = xmalloc (allocate);
2199                     }
2200                   ctxp->osb_depth++;
2201                   CURRENT_OSB (ctxp) = 1;
2202                 }
2203 |       dims OSB_TK CSB_TK
2204                 { CURRENT_OSB (ctxp)++; }
2205 |       dims OSB_TK error
2206                 { yyerror ("']' expected"); RECOVER;}
2207 ;
2208
2209 field_access:
2210         primary DOT_TK identifier
2211                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2212                 /*  FIXME - REWRITE TO:
2213                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2214 |       SUPER_TK DOT_TK identifier
2215                 {
2216                   tree super_wfl = build_wfl_node (super_identifier_node);
2217                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
2218                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2219                 }
2220 |       SUPER_TK error
2221                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2222 ;
2223
2224 method_invocation:
2225         name OP_TK CP_TK
2226                 { $$ = build_method_invocation ($1, NULL_TREE); }
2227 |       name OP_TK argument_list CP_TK
2228                 { $$ = build_method_invocation ($1, $3); }
2229 |       primary DOT_TK identifier OP_TK CP_TK
2230                 {
2231                   if (TREE_CODE ($1) == THIS_EXPR)
2232                     $$ = build_this_super_qualified_invocation
2233                       (1, $3, NULL_TREE, 0, $2.location);
2234                   else
2235                     {
2236                       tree invok = build_method_invocation ($3, NULL_TREE);
2237                       $$ = make_qualified_primary ($1, invok, $2.location);
2238                     }
2239                 }
2240 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2241                 {
2242                   if (TREE_CODE ($1) == THIS_EXPR)
2243                     $$ = build_this_super_qualified_invocation
2244                       (1, $3, $5, 0, $2.location);
2245                   else
2246                     {
2247                       tree invok = build_method_invocation ($3, $5);
2248                       $$ = make_qualified_primary ($1, invok, $2.location);
2249                     }
2250                 }
2251 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2252                 {
2253                   $$ = build_this_super_qualified_invocation
2254                     (0, $3, NULL_TREE, $1.location, $2.location);
2255                 }
2256 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2257                 {
2258                   $$ = build_this_super_qualified_invocation
2259                     (0, $3, $5, $1.location, $2.location);
2260                 }
2261         /* Screws up thing. I let it here until I'm convinced it can
2262            be removed. FIXME
2263 |       primary DOT_TK error
2264                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2265 |       SUPER_TK DOT_TK error CP_TK
2266                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2267 |       SUPER_TK DOT_TK error DOT_TK
2268                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2269 ;
2270
2271 array_access:
2272         name OSB_TK expression CSB_TK
2273                 { $$ = build_array_ref ($2.location, $1, $3); }
2274 |       primary_no_new_array OSB_TK expression CSB_TK
2275                 { $$ = build_array_ref ($2.location, $1, $3); }
2276 |       name OSB_TK error
2277                 {
2278                   yyerror ("Missing term and ']' expected");
2279                   DRECOVER(array_access);
2280                 }
2281 |       name OSB_TK expression error
2282                 {
2283                   yyerror ("']' expected");
2284                   DRECOVER(array_access);
2285                 }
2286 |       primary_no_new_array OSB_TK error
2287                 {
2288                   yyerror ("Missing term and ']' expected");
2289                   DRECOVER(array_access);
2290                 }
2291 |       primary_no_new_array OSB_TK expression error
2292                 {
2293                   yyerror ("']' expected");
2294                   DRECOVER(array_access);
2295                 }
2296 ;
2297
2298 postfix_expression:
2299         primary
2300 |       name
2301 |       post_increment_expression
2302 |       post_decrement_expression
2303 ;
2304
2305 post_increment_expression:
2306         postfix_expression INCR_TK
2307                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2308 ;
2309
2310 post_decrement_expression:
2311         postfix_expression DECR_TK
2312                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2313 ;
2314
2315 trap_overflow_corner_case:
2316         pre_increment_expression
2317 |       pre_decrement_expression
2318 |       PLUS_TK unary_expression
2319                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2320 |       unary_expression_not_plus_minus
2321 |       PLUS_TK error
2322                 {yyerror ("Missing term"); RECOVER}
2323 ;
2324
2325 unary_expression:
2326         trap_overflow_corner_case
2327                 {
2328                   error_if_numeric_overflow ($1);
2329                   $$ = $1;
2330                 }
2331 |       MINUS_TK trap_overflow_corner_case
2332                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2333 |       MINUS_TK error
2334                 {yyerror ("Missing term"); RECOVER}
2335 ;
2336
2337 pre_increment_expression:
2338         INCR_TK unary_expression
2339                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2340 |       INCR_TK error
2341                 {yyerror ("Missing term"); RECOVER}
2342 ;
2343
2344 pre_decrement_expression:
2345         DECR_TK unary_expression
2346                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2347 |       DECR_TK error
2348                 {yyerror ("Missing term"); RECOVER}
2349 ;
2350
2351 unary_expression_not_plus_minus:
2352         postfix_expression
2353 |       NOT_TK unary_expression
2354                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2355 |       NEG_TK unary_expression
2356                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2357 |       cast_expression
2358 |       NOT_TK error
2359                 {yyerror ("Missing term"); RECOVER}
2360 |       NEG_TK error
2361                 {yyerror ("Missing term"); RECOVER}
2362 ;
2363
2364 cast_expression:                /* Error handling here is potentially weak */
2365         OP_TK primitive_type dims CP_TK unary_expression
2366                 {
2367                   tree type = $2;
2368                   int osb = pop_current_osb (ctxp);
2369                   while (osb--)
2370                     type = build_java_array_type (type, -1);
2371                   $$ = build_cast ($1.location, type, $5);
2372                 }
2373 |       OP_TK primitive_type CP_TK unary_expression
2374                 { $$ = build_cast ($1.location, $2, $4); }
2375 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2376                 { $$ = build_cast ($1.location, $2, $4); }
2377 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2378                 {
2379                   const char *ptr;
2380                   int osb = pop_current_osb (ctxp);
2381                   obstack_grow (&temporary_obstack,
2382                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2383                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2384                   while (osb--)
2385                     obstack_grow (&temporary_obstack, "[]", 2);
2386                   obstack_1grow (&temporary_obstack, '\0');
2387                   ptr = obstack_finish (&temporary_obstack);
2388                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2389                   $$ = build_cast ($1.location, $2, $5);
2390                 }
2391 |       OP_TK primitive_type OSB_TK error
2392                 {yyerror ("']' expected, invalid type expression");}
2393 |       OP_TK error
2394                 {
2395                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2396                   RECOVER;
2397                 }
2398 |       OP_TK primitive_type dims CP_TK error
2399                 {yyerror ("Missing term"); RECOVER;}
2400 |       OP_TK primitive_type CP_TK error
2401                 {yyerror ("Missing term"); RECOVER;}
2402 |       OP_TK name dims CP_TK error
2403                 {yyerror ("Missing term"); RECOVER;}
2404 ;
2405
2406 multiplicative_expression:
2407         unary_expression
2408 |       multiplicative_expression MULT_TK unary_expression
2409                 {
2410                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2411                                     $2.location, $1, $3);
2412                 }
2413 |       multiplicative_expression DIV_TK unary_expression
2414                 {
2415                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2416                                     $1, $3);
2417                 }
2418 |       multiplicative_expression REM_TK unary_expression
2419                 {
2420                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2421                                     $1, $3);
2422                 }
2423 |       multiplicative_expression MULT_TK error
2424                 {yyerror ("Missing term"); RECOVER;}
2425 |       multiplicative_expression DIV_TK error
2426                 {yyerror ("Missing term"); RECOVER;}
2427 |       multiplicative_expression REM_TK error
2428                 {yyerror ("Missing term"); RECOVER;}
2429 ;
2430
2431 additive_expression:
2432         multiplicative_expression
2433 |       additive_expression PLUS_TK multiplicative_expression
2434                 {
2435                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2436                                     $1, $3);
2437                 }
2438 |       additive_expression MINUS_TK multiplicative_expression
2439                 {
2440                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2441                                     $1, $3);
2442                 }
2443 |       additive_expression PLUS_TK error
2444                 {yyerror ("Missing term"); RECOVER;}
2445 |       additive_expression MINUS_TK error
2446                 {yyerror ("Missing term"); RECOVER;}
2447 ;
2448
2449 shift_expression:
2450         additive_expression
2451 |       shift_expression LS_TK additive_expression
2452                 {
2453                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2454                                     $1, $3);
2455                 }
2456 |       shift_expression SRS_TK additive_expression
2457                 {
2458                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2459                                     $1, $3);
2460                 }
2461 |       shift_expression ZRS_TK additive_expression
2462                 {
2463                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2464                                     $1, $3);
2465                 }
2466 |       shift_expression LS_TK error
2467                 {yyerror ("Missing term"); RECOVER;}
2468 |       shift_expression SRS_TK error
2469                 {yyerror ("Missing term"); RECOVER;}
2470 |       shift_expression ZRS_TK error
2471                 {yyerror ("Missing term"); RECOVER;}
2472 ;
2473
2474 relational_expression:
2475         shift_expression
2476 |       relational_expression LT_TK shift_expression
2477                 {
2478                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2479                                     $1, $3);
2480                 }
2481 |       relational_expression GT_TK shift_expression
2482                 {
2483                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2484                                     $1, $3);
2485                 }
2486 |       relational_expression LTE_TK shift_expression
2487                 {
2488                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2489                                     $1, $3);
2490                 }
2491 |       relational_expression GTE_TK shift_expression
2492                 {
2493                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2494                                     $1, $3);
2495                 }
2496 |       relational_expression INSTANCEOF_TK reference_type
2497                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2498 |       relational_expression LT_TK error
2499                 {yyerror ("Missing term"); RECOVER;}
2500 |       relational_expression GT_TK error
2501                 {yyerror ("Missing term"); RECOVER;}
2502 |       relational_expression LTE_TK error
2503                 {yyerror ("Missing term"); RECOVER;}
2504 |       relational_expression GTE_TK error
2505                 {yyerror ("Missing term"); RECOVER;}
2506 |       relational_expression INSTANCEOF_TK error
2507                 {yyerror ("Invalid reference type"); RECOVER;}
2508 ;
2509
2510 equality_expression:
2511         relational_expression
2512 |       equality_expression EQ_TK relational_expression
2513                 {
2514                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2515                                     $1, $3);
2516                 }
2517 |       equality_expression NEQ_TK relational_expression
2518                 {
2519                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2520                                     $1, $3);
2521                 }
2522 |       equality_expression EQ_TK error
2523                 {yyerror ("Missing term"); RECOVER;}
2524 |       equality_expression NEQ_TK error
2525                 {yyerror ("Missing term"); RECOVER;}
2526 ;
2527
2528 and_expression:
2529         equality_expression
2530 |       and_expression AND_TK equality_expression
2531                 {
2532                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2533                                     $1, $3);
2534                 }
2535 |       and_expression AND_TK error
2536                 {yyerror ("Missing term"); RECOVER;}
2537 ;
2538
2539 exclusive_or_expression:
2540         and_expression
2541 |       exclusive_or_expression XOR_TK and_expression
2542                 {
2543                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2544                                     $1, $3);
2545                 }
2546 |       exclusive_or_expression XOR_TK error
2547                 {yyerror ("Missing term"); RECOVER;}
2548 ;
2549
2550 inclusive_or_expression:
2551         exclusive_or_expression
2552 |       inclusive_or_expression OR_TK exclusive_or_expression
2553                 {
2554                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2555                                     $1, $3);
2556                 }
2557 |       inclusive_or_expression OR_TK error
2558                 {yyerror ("Missing term"); RECOVER;}
2559 ;
2560
2561 conditional_and_expression:
2562         inclusive_or_expression
2563 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2564                 {
2565                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2566                                     $1, $3);
2567                 }
2568 |       conditional_and_expression BOOL_AND_TK error
2569                 {yyerror ("Missing term"); RECOVER;}
2570 ;
2571
2572 conditional_or_expression:
2573         conditional_and_expression
2574 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2575                 {
2576                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2577                                     $1, $3);
2578                 }
2579 |       conditional_or_expression BOOL_OR_TK error
2580                 {yyerror ("Missing term"); RECOVER;}
2581 ;
2582
2583 conditional_expression:         /* Error handling here is weak */
2584         conditional_or_expression
2585 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2586                 {
2587                   $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2588                   EXPR_WFL_LINECOL ($$) = $2.location;
2589                 }
2590 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2591                 {
2592                   YYERROR_NOW;
2593                   yyerror ("Missing term");
2594                   DRECOVER (1);
2595                 }
2596 |       conditional_or_expression REL_QM_TK error
2597                 {yyerror ("Missing term"); DRECOVER (2);}
2598 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2599                 {yyerror ("Missing term"); DRECOVER (3);}
2600 ;
2601
2602 assignment_expression:
2603         conditional_expression
2604 |       assignment
2605 ;
2606
2607 assignment:
2608         left_hand_side assignment_operator assignment_expression
2609                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2610 |       left_hand_side assignment_operator error
2611                 {
2612                   YYNOT_TWICE yyerror ("Missing term");
2613                   DRECOVER (assign);
2614                 }
2615 ;
2616
2617 left_hand_side:
2618         name
2619 |       field_access
2620 |       array_access
2621 ;
2622
2623 assignment_operator:
2624         ASSIGN_ANY_TK
2625 |       ASSIGN_TK
2626 ;
2627
2628 expression:
2629         assignment_expression
2630 ;
2631
2632 constant_expression:
2633         expression
2634 ;
2635
2636 %%
2637
2638 /* Helper function to retrieve an OSB count. Should be used when the
2639    `dims:' rule is being used.  */
2640
2641 static int
2642 pop_current_osb (struct parser_ctxt *ctxp)
2643 {
2644   int to_return;
2645
2646   if (ctxp->osb_depth < 0)
2647     abort ();
2648
2649   to_return = CURRENT_OSB (ctxp);
2650   ctxp->osb_depth--;
2651
2652   return to_return;
2653 }
2654
2655 \f
2656
2657 /* This section of the code deal with save/restoring parser contexts.
2658    Add mode documentation here. FIXME */
2659
2660 /* Helper function. Create a new parser context. With
2661    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2662    context is copied, otherwise, the new context is zeroed. The newly
2663    created context becomes the current one.  */
2664
2665 static void
2666 create_new_parser_context (int copy_from_previous)
2667 {
2668   struct parser_ctxt *new;
2669
2670   new = ggc_alloc (sizeof (struct parser_ctxt));
2671   if (copy_from_previous)
2672     {
2673       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2674       /* This flag, indicating the context saves global values,
2675          should only be set by java_parser_context_save_global.  */
2676       new->saved_data_ctx = 0;
2677     }
2678   else
2679     memset (new, 0, sizeof (struct parser_ctxt));
2680
2681   new->next = ctxp;
2682   ctxp = new;
2683 }
2684
2685 /* Create a new parser context and make it the current one. */
2686
2687 void
2688 java_push_parser_context (void)
2689 {
2690   create_new_parser_context (0);
2691 }
2692
2693 void
2694 java_pop_parser_context (int generate)
2695 {
2696   tree current;
2697   struct parser_ctxt *toFree, *next;
2698
2699   if (!ctxp)
2700     return;
2701
2702   toFree = ctxp;
2703   next = ctxp->next;
2704   if (next)
2705     {
2706       input_line = ctxp->lineno;
2707       current_class = ctxp->class_type;
2708     }
2709
2710   /* If the old and new lexers differ, then free the old one.  */
2711   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2712     java_destroy_lexer (ctxp->lexer);
2713
2714   /* Set the single import class file flag to 0 for the current list
2715      of imported things */
2716   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2717     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2718
2719   /* And restore those of the previous context */
2720   if ((ctxp = next))            /* Assignment is really meant here */
2721     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2722       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2723
2724   /* If we pushed a context to parse a class intended to be generated,
2725      we keep it so we can remember the class. What we could actually
2726      do is to just update a list of class names.  */
2727   if (generate)
2728     {
2729       toFree->next = ctxp_for_generation;
2730       ctxp_for_generation = toFree;
2731     }
2732 }
2733
2734 /* Create a parser context for the use of saving some global
2735    variables.  */
2736
2737 void
2738 java_parser_context_save_global (void)
2739 {
2740   if (!ctxp)
2741     {
2742       java_push_parser_context ();
2743       ctxp->saved_data_ctx = 1;
2744     }
2745
2746   /* If this context already stores data, create a new one suitable
2747      for data storage. */
2748   else if (ctxp->saved_data)
2749     {
2750       create_new_parser_context (1);
2751       ctxp->saved_data_ctx = 1;
2752     }
2753
2754   ctxp->lineno = input_line;
2755   ctxp->class_type = current_class;
2756   ctxp->filename = input_filename;
2757   ctxp->function_decl = current_function_decl;
2758   ctxp->saved_data = 1;
2759 }
2760
2761 /* Restore some global variables from the previous context. Make the
2762    previous context the current one.  */
2763
2764 void
2765 java_parser_context_restore_global (void)
2766 {
2767   input_line = ctxp->lineno;
2768   current_class = ctxp->class_type;
2769   input_filename = ctxp->filename;
2770   if (wfl_operator)
2771     {
2772       tree s;
2773       BUILD_FILENAME_IDENTIFIER_NODE (s, input_filename);
2774       EXPR_WFL_FILENAME_NODE (wfl_operator) = s;
2775     }
2776   current_function_decl = ctxp->function_decl;
2777   ctxp->saved_data = 0;
2778   if (ctxp->saved_data_ctx)
2779     java_pop_parser_context (0);
2780 }
2781
2782 /* Suspend vital data for the current class/function being parsed so
2783    that an other class can be parsed. Used to let local/anonymous
2784    classes be parsed.  */
2785
2786 static void
2787 java_parser_context_suspend (void)
2788 {
2789   /* This makes debugging through java_debug_context easier */
2790   static const char *const name = "<inner buffer context>";
2791
2792   /* Duplicate the previous context, use it to save the globals we're
2793      interested in */
2794   create_new_parser_context (1);
2795   ctxp->function_decl = current_function_decl;
2796   ctxp->class_type = current_class;
2797
2798   /* Then create a new context which inherits all data from the
2799      previous one. This will be the new current context  */
2800   create_new_parser_context (1);
2801
2802   /* Help debugging */
2803   ctxp->next->filename = name;
2804 }
2805
2806 /* Resume vital data for the current class/function being parsed so
2807    that an other class can be parsed. Used to let local/anonymous
2808    classes be parsed.  The trick is the data storing file position
2809    informations must be restored to their current value, so parsing
2810    can resume as if no context was ever saved. */
2811
2812 static void
2813 java_parser_context_resume (void)
2814 {
2815   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2816   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2817   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2818
2819   /* We need to inherit the list of classes to complete/generate */
2820   restored->classd_list = old->classd_list;
2821   restored->class_list = old->class_list;
2822
2823   /* Restore the current class and function from the saver */
2824   current_class = saver->class_type;
2825   current_function_decl = saver->function_decl;
2826
2827   /* Retrieve the restored context */
2828   ctxp = restored;
2829
2830   /* Re-installed the data for the parsing to carry on */
2831   memcpy (&ctxp->marker_begining, &old->marker_begining,
2832           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2833 }
2834
2835 /* Add a new anchor node to which all statement(s) initializing static
2836    and non static initialized upon declaration field(s) will be
2837    linked.  */
2838
2839 static void
2840 java_parser_context_push_initialized_field (void)
2841 {
2842   tree node;
2843
2844   node = build_tree_list (NULL_TREE, NULL_TREE);
2845   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2846   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2847
2848   node = build_tree_list (NULL_TREE, NULL_TREE);
2849   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2850   CPC_INITIALIZER_LIST (ctxp) = node;
2851
2852   node = build_tree_list (NULL_TREE, NULL_TREE);
2853   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2854   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2855 }
2856
2857 /* Pop the lists of initialized field. If this lists aren't empty,
2858    remember them so we can use it to create and populate the finit$
2859    or <clinit> functions. */
2860
2861 static void
2862 java_parser_context_pop_initialized_field (void)
2863 {
2864   tree stmts;
2865   tree class_type = TREE_TYPE (GET_CPC ());
2866
2867   if (CPC_INITIALIZER_LIST (ctxp))
2868     {
2869       stmts = CPC_INITIALIZER_STMT (ctxp);
2870       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2871       if (stmts && !java_error_count)
2872         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2873     }
2874
2875   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2876     {
2877       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2878       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2879         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2880       /* Keep initialization in order to enforce 8.5 */
2881       if (stmts && !java_error_count)
2882         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2883     }
2884
2885   /* JDK 1.1 instance initializers */
2886   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2887     {
2888       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2889       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2890         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2891       if (stmts && !java_error_count)
2892         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2893     }
2894 }
2895
2896 static tree
2897 reorder_static_initialized (tree list)
2898 {
2899   /* We have to keep things in order. The alias initializer have to
2900      come first, then the initialized regular field, in reverse to
2901      keep them in lexical order. */
2902   tree marker, previous = NULL_TREE;
2903   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2904     if (TREE_CODE (marker) == TREE_LIST
2905         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2906       break;
2907
2908   /* No static initialized, the list is fine as is */
2909   if (!previous)
2910     list = TREE_CHAIN (marker);
2911
2912   /* No marker? reverse the whole list */
2913   else if (!marker)
2914     list = nreverse (list);
2915
2916   /* Otherwise, reverse what's after the marker and the new reordered
2917      sublist will replace the marker. */
2918   else
2919     {
2920       TREE_CHAIN (previous) = NULL_TREE;
2921       list = nreverse (list);
2922       list = chainon (TREE_CHAIN (marker), list);
2923     }
2924   return list;
2925 }
2926
2927 /* Helper functions to dump the parser context stack.  */
2928
2929 #define TAB_CONTEXT(C) \
2930   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2931
2932 static void
2933 java_debug_context_do (int tab)
2934 {
2935   struct parser_ctxt *copy = ctxp;
2936   while (copy)
2937     {
2938       TAB_CONTEXT (tab);
2939       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2940       TAB_CONTEXT (tab);
2941       fprintf (stderr, "filename: %s\n", copy->filename);
2942       TAB_CONTEXT (tab);
2943       fprintf (stderr, "lineno: %d\n", copy->lineno);
2944       TAB_CONTEXT (tab);
2945       fprintf (stderr, "package: %s\n",
2946                (copy->package ?
2947                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2948       TAB_CONTEXT (tab);
2949       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2950       TAB_CONTEXT (tab);
2951       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2952       copy = copy->next;
2953       tab += 2;
2954     }
2955 }
2956
2957 /* Dump the stacked up parser contexts. Intended to be called from a
2958    debugger.  */
2959
2960 void
2961 java_debug_context (void)
2962 {
2963   java_debug_context_do (0);
2964 }
2965
2966 \f
2967
2968 /* Flag for the error report routine to issue the error the first time
2969    it's called (overriding the default behavior which is to drop the
2970    first invocation and honor the second one, taking advantage of a
2971    richer context.  */
2972 static int force_error = 0;
2973
2974 /* Reporting an constructor invocation error.  */
2975 static void
2976 parse_ctor_invocation_error (void)
2977 {
2978   if (DECL_CONSTRUCTOR_P (current_function_decl))
2979     yyerror ("Constructor invocation must be first thing in a constructor");
2980   else
2981     yyerror ("Only constructors can invoke constructors");
2982 }
2983
2984 /* Reporting JDK1.1 features not implemented.  */
2985
2986 static tree
2987 parse_jdk1_1_error (const char *msg)
2988 {
2989   sorry (": `%s' JDK1.1(TM) feature", msg);
2990   java_error_count++;
2991   return build_java_empty_stmt ();
2992 }
2993
2994 static int do_warning = 0;
2995
2996 void
2997 yyerror (const char *msg)
2998 {
2999   static java_lc elc;
3000   static int  prev_lineno;
3001   static const char *prev_msg;
3002
3003   int save_lineno;
3004   char *remainder, *code_from_source;
3005
3006   if (!force_error && prev_lineno == input_line)
3007     return;
3008
3009   /* Save current error location but report latter, when the context is
3010      richer.  */
3011   if (ctxp->java_error_flag == 0)
3012     {
3013       ctxp->java_error_flag = 1;
3014       elc = ctxp->elc;
3015       /* Do something to use the previous line if we're reaching the
3016          end of the file... */
3017 #ifdef VERBOSE_SKELETON
3018       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3019 #endif
3020       return;
3021     }
3022
3023   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3024   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3025     return;
3026
3027   ctxp->java_error_flag = 0;
3028   if (do_warning)
3029     java_warning_count++;
3030   else
3031     java_error_count++;
3032
3033   if (elc.col == 0 && msg && msg[1] == ';')
3034     {
3035       elc.col  = ctxp->p_line->char_col-1;
3036       elc.line = ctxp->p_line->lineno;
3037     }
3038
3039   save_lineno = input_line;
3040   prev_lineno = input_line = elc.line;
3041   prev_msg = msg;
3042
3043   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3044   obstack_grow0 (&temporary_obstack,
3045                  code_from_source, strlen (code_from_source));
3046   remainder = obstack_finish (&temporary_obstack);
3047   if (do_warning)
3048     warning ("%s.\n%s", msg, remainder);
3049   else
3050     error ("%s.\n%s", msg, remainder);
3051
3052   /* This allow us to cheaply avoid an extra 'Invalid expression
3053      statement' error report when errors have been already reported on
3054      the same line. This occurs when we report an error but don't have
3055      a synchronization point other than ';', which
3056      expression_statement is the only one to take care of.  */
3057   ctxp->prevent_ese = input_line = save_lineno;
3058 }
3059
3060 static void
3061 issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
3062 {
3063   const char *saved, *saved_input_filename;
3064   char buffer [4096];
3065   vsprintf (buffer, msg, ap);
3066   force_error = 1;
3067
3068   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3069   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3070                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3071
3072   /* We have a CL, that's a good reason for using it if it contains data */
3073   saved = ctxp->filename;
3074   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3075     ctxp->filename = EXPR_WFL_FILENAME (cl);
3076   saved_input_filename = input_filename;
3077   input_filename = ctxp->filename;
3078   java_error (NULL);
3079   java_error (buffer);
3080   ctxp->filename = saved;
3081   input_filename = saved_input_filename;
3082   force_error = 0;
3083 }
3084
3085 /* Issue an error message at a current source line CL */
3086
3087 void
3088 parse_error_context (tree cl, const char *msg, ...)
3089 {
3090   va_list ap;
3091   va_start (ap, msg);
3092   issue_warning_error_from_context (cl, msg, ap);
3093   va_end (ap);
3094 }
3095
3096 /* Issue a warning at a current source line CL */
3097
3098 static void
3099 parse_warning_context (tree cl, const char *msg, ...)
3100 {
3101   va_list ap;
3102   va_start (ap, msg);
3103
3104   force_error = do_warning = 1;
3105   issue_warning_error_from_context (cl, msg, ap);
3106   do_warning = force_error = 0;
3107   va_end (ap);
3108 }
3109
3110 static tree
3111 find_expr_with_wfl (tree node)
3112 {
3113   while (node)
3114     {
3115       char code;
3116       tree to_return;
3117
3118       switch (TREE_CODE (node))
3119         {
3120         case BLOCK:
3121           node = BLOCK_EXPR_BODY (node);
3122           continue;
3123
3124         case COMPOUND_EXPR:
3125           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3126           if (to_return)
3127             return to_return;
3128           node = TREE_OPERAND (node, 1);
3129           continue;
3130
3131         case LOOP_EXPR:
3132           node = TREE_OPERAND (node, 0);
3133           continue;
3134
3135         case LABELED_BLOCK_EXPR:
3136           node = TREE_OPERAND (node, 1);
3137           continue;
3138
3139         default:
3140           code = TREE_CODE_CLASS (TREE_CODE (node));
3141           if (((code == '1') || (code == '2') || (code == 'e'))
3142               && EXPR_WFL_LINECOL (node))
3143             return node;
3144           return NULL_TREE;
3145         }
3146     }
3147   return NULL_TREE;
3148 }
3149
3150 /* Issue a missing return statement error. Uses METHOD to figure the
3151    last line of the method the error occurs in.  */
3152
3153 static void
3154 missing_return_error (tree method)
3155 {
3156   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3157   parse_error_context (wfl_operator, "Missing return statement");
3158 }
3159
3160 /* Issue an unreachable statement error. From NODE, find the next
3161    statement to report appropriately.  */
3162 static void
3163 unreachable_stmt_error (tree node)
3164 {
3165   /* Browse node to find the next expression node that has a WFL. Use
3166      the location to report the error */
3167   if (TREE_CODE (node) == COMPOUND_EXPR)
3168     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3169   else
3170     node = find_expr_with_wfl (node);
3171
3172   if (node)
3173     {
3174       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3175       parse_error_context (wfl_operator, "Unreachable statement");
3176     }
3177   else
3178     abort ();
3179 }
3180
3181 static int
3182 not_accessible_field_error (tree wfl, tree decl)
3183 {
3184   parse_error_context
3185     (wfl, "Can't access %s field `%s.%s' from `%s'",
3186      accessibility_string (get_access_flags_from_decl (decl)),
3187      GET_TYPE_NAME (DECL_CONTEXT (decl)),
3188      IDENTIFIER_POINTER (DECL_NAME (decl)),
3189      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3190   return 1;
3191 }
3192
3193 int
3194 java_report_errors (void)
3195 {
3196   if (java_error_count)
3197     fprintf (stderr, "%d error%s",
3198              java_error_count, (java_error_count == 1 ? "" : "s"));
3199   if (java_warning_count)
3200     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3201              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3202   if (java_error_count || java_warning_count)
3203     putc ('\n', stderr);
3204   return java_error_count;
3205 }
3206
3207 static char *
3208 java_accstring_lookup (int flags)
3209 {
3210   static char buffer [80];
3211 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3212
3213   /* Access modifier looked-up first for easier report on forbidden
3214      access. */
3215   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3216   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3217   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3218   if (flags & ACC_STATIC) COPY_RETURN ("static");
3219   if (flags & ACC_FINAL) COPY_RETURN ("final");
3220   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3221   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3222   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3223   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3224   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3225   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3226
3227   buffer [0] = '\0';
3228   return buffer;
3229 #undef COPY_RETURN
3230 }
3231
3232 /* Returns a string denoting the accessibility of a class or a member as
3233    indicated by FLAGS.  We need a separate function from
3234    java_accstring_lookup, as the latter can return spurious "static", etc.
3235    if package-private access is defined (in which case none of the
3236    relevant access control bits in FLAGS is set).  */
3237
3238 static const char *
3239 accessibility_string (int flags)
3240 {
3241   if (flags & ACC_PRIVATE) return "private";
3242   if (flags & ACC_PROTECTED) return "protected";
3243   if (flags & ACC_PUBLIC) return "public";
3244
3245   return "package-private";
3246 }
3247
3248 /* Issuing error messages upon redefinition of classes, interfaces or
3249    variables. */
3250
3251 static void
3252 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3253 {
3254   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3255                        context, IDENTIFIER_POINTER (id),
3256                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3257   /* Here we should point out where its redefined. It's a unicode. FIXME */
3258 }
3259
3260 static void
3261 variable_redefinition_error (tree context, tree name, tree type, int line)
3262 {
3263   const char *type_name;
3264
3265   /* Figure a proper name for type. We might haven't resolved it */
3266   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3267     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3268   else
3269     type_name = lang_printable_name (type, 0);
3270
3271   parse_error_context (context,
3272                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3273                        IDENTIFIER_POINTER (name),
3274                        type_name, IDENTIFIER_POINTER (name), line);
3275 }
3276
3277 /* If ANAME is terminated with `[]', it indicates an array. This
3278    function returns the number of `[]' found and if this number is
3279    greater than zero, it extracts the array type name and places it in
3280    the node pointed to by TRIMMED unless TRIMMED is null.  */
3281
3282 static int
3283 build_type_name_from_array_name (tree aname, tree *trimmed)
3284 {
3285   const char *name = IDENTIFIER_POINTER (aname);
3286   int len = IDENTIFIER_LENGTH (aname);
3287   int array_dims;
3288
3289   STRING_STRIP_BRACKETS (name, len, array_dims);
3290
3291   if (array_dims && trimmed)
3292     *trimmed = get_identifier_with_length (name, len);
3293
3294   return array_dims;
3295 }
3296
3297 static tree
3298 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3299 {
3300   int more_dims = 0;
3301
3302   /* Eventually get more dims */
3303   more_dims = build_type_name_from_array_name (name, &name);
3304
3305   /* If we have, then craft a new type for this variable */
3306   if (more_dims)
3307     {
3308       tree save = type;
3309
3310       /* If we have a pointer, use its type */
3311       if (TREE_CODE (type) == POINTER_TYPE)
3312         type = TREE_TYPE (type);
3313
3314       /* Building the first dimension of a primitive type uses this
3315          function */
3316       if (JPRIMITIVE_TYPE_P (type))
3317         {
3318           type = build_java_array_type (type, -1);
3319           more_dims--;
3320         }
3321       /* Otherwise, if we have a WFL for this type, use it (the type
3322          is already an array on an unresolved type, and we just keep
3323          on adding dimensions) */
3324       else if (type_wfl)
3325         {
3326           type = type_wfl;
3327           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3328                                                         NULL);
3329         }
3330
3331       /* Add all the dimensions */
3332       while (more_dims--)
3333         type = build_unresolved_array_type (type);
3334
3335       /* The type may have been incomplete in the first place */
3336       if (type_wfl)
3337         type = obtain_incomplete_type (type);
3338     }
3339
3340   if (ret_name)
3341     *ret_name = name;
3342   return type;
3343 }
3344
3345 /* Build something that the type identifier resolver will identify as
3346    being an array to an unresolved type. TYPE_WFL is a WFL on a
3347    identifier. */
3348
3349 static tree
3350 build_unresolved_array_type (tree type_or_wfl)
3351 {
3352   const char *ptr;
3353   tree wfl;
3354
3355   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3356      just create a array type */
3357   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3358     return build_java_array_type (type_or_wfl, -1);
3359
3360   obstack_grow (&temporary_obstack,
3361                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3362                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3363   obstack_grow0 (&temporary_obstack, "[]", 2);
3364   ptr = obstack_finish (&temporary_obstack);
3365   wfl = build_expr_wfl (get_identifier (ptr),
3366                         EXPR_WFL_FILENAME (type_or_wfl),
3367                         EXPR_WFL_LINENO (type_or_wfl),
3368                         EXPR_WFL_COLNO (type_or_wfl));
3369   /* Re-install the existing qualifications so that the type can be
3370      resolved properly. */
3371   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3372   return wfl;
3373 }
3374
3375 static void
3376 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3377 {
3378   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3379     parse_error_context (wfl, "Interface `%s' repeated",
3380                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3381 }
3382
3383 /* Bulk of common class/interface checks. Return 1 if an error was
3384    encountered. TAG is 0 for a class, 1 for an interface.  */
3385
3386 static int
3387 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3388                                 tree qualified_name, tree decl, tree cl)
3389 {
3390   tree node;
3391   int sca = 0;                  /* Static class allowed */
3392   int icaf = 0;                 /* Inner class allowed flags */
3393   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3394
3395   if (!quiet_flag)
3396     fprintf (stderr, " %s%s %s",
3397              (CPC_INNER_P () ? "inner" : ""),
3398              (is_interface ? "interface" : "class"),
3399              IDENTIFIER_POINTER (qualified_name));
3400
3401   /* Scope of an interface/class type name:
3402        - Can't be imported by a single type import
3403        - Can't already exists in the package */
3404   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3405       && (node = find_name_in_single_imports (raw_name))
3406       && !CPC_INNER_P ())
3407     {
3408       parse_error_context
3409         (cl, "%s name `%s' clashes with imported type `%s'",
3410          (is_interface ? "Interface" : "Class"),
3411          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3412       return 1;
3413     }
3414   if (decl && CLASS_COMPLETE_P (decl))
3415     {
3416       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3417                                    qualified_name, decl, cl);
3418       return 1;
3419     }
3420
3421   if (check_inner_class_redefinition (raw_name, cl))
3422     return 1;
3423
3424   /* If public, file name should match class/interface name, except
3425      when dealing with an inner class */
3426   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3427     {
3428       const char *f;
3429
3430       for (f = &input_filename [strlen (input_filename)];
3431            f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3432            f--)
3433         ;
3434       if (IS_DIR_SEPARATOR (f[0]))
3435         f++;
3436       if (strncmp (IDENTIFIER_POINTER (raw_name),
3437                    f , IDENTIFIER_LENGTH (raw_name)) ||
3438           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3439         parse_error_context
3440           (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3441                              (is_interface ? "interface" : "class"),
3442                              IDENTIFIER_POINTER (qualified_name),
3443                              IDENTIFIER_POINTER (raw_name));
3444     }
3445
3446   /* Static classes can be declared only in top level classes. Note:
3447      once static, a inner class is a top level class. */
3448   if (flags & ACC_STATIC)
3449     {
3450       /* Catch the specific error of declaring an class inner class
3451          with no toplevel enclosing class. Prevent check_modifiers from
3452          complaining a second time */
3453       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3454         {
3455           parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3456                                IDENTIFIER_POINTER (qualified_name));
3457           sca = ACC_STATIC;
3458         }
3459       /* Else, in the context of a top-level class declaration, let
3460          `check_modifiers' do its job, otherwise, give it a go */
3461       else
3462         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3463     }
3464
3465   /* Inner classes can be declared private or protected
3466      within their enclosing classes. */
3467   if (CPC_INNER_P ())
3468     {
3469       /* A class which is local to a block can't be public, private,
3470          protected or static. But it is created final, so allow this
3471          one. */
3472       if (current_function_decl)
3473         icaf = sca = uaaf = ACC_FINAL;
3474       else
3475         {
3476           check_modifiers_consistency (flags);
3477           icaf = ACC_PROTECTED;
3478           if (! CLASS_INTERFACE (GET_CPC ()))
3479             icaf |= ACC_PRIVATE;
3480         }
3481     }
3482
3483   if (is_interface)
3484     {
3485       if (CPC_INNER_P ())
3486         uaaf = INTERFACE_INNER_MODIFIERS;
3487       else
3488         uaaf = INTERFACE_MODIFIERS;
3489
3490       check_modifiers ("Illegal modifier `%s' for interface declaration",
3491                        flags, uaaf);
3492     }
3493   else
3494     check_modifiers ((current_function_decl ?
3495                       "Illegal modifier `%s' for local class declaration" :
3496                       "Illegal modifier `%s' for class declaration"),
3497                      flags, uaaf|sca|icaf);
3498   return 0;
3499 }
3500
3501 /* Construct a nested class name.  If the final component starts with
3502    a digit, return true.  Otherwise return false.  */
3503 static int
3504 make_nested_class_name (tree cpc_list)
3505 {
3506   tree name;
3507
3508   if (!cpc_list)
3509     return 0;
3510
3511   make_nested_class_name (TREE_CHAIN (cpc_list));
3512
3513   /* Pick the qualified name when dealing with the first upmost
3514      enclosing class */
3515   name = (TREE_CHAIN (cpc_list)
3516           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3517   obstack_grow (&temporary_obstack,
3518                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3519   obstack_1grow (&temporary_obstack, '$');
3520
3521   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3522 }
3523
3524 /* Can't redefine a class already defined in an earlier scope. */
3525
3526 static int
3527 check_inner_class_redefinition (tree raw_name, tree cl)
3528 {
3529   tree scope_list;
3530
3531   for (scope_list = GET_CPC_LIST (); scope_list;
3532        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3533     if (raw_name == GET_CPC_UN_NODE (scope_list))
3534       {
3535         parse_error_context
3536           (cl, "The class name `%s' is already defined in this scope. An inner class may not have the same simple name as any of its enclosing classes",
3537            IDENTIFIER_POINTER (raw_name));
3538         return 1;
3539       }
3540   return 0;
3541 }
3542
3543 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3544    we remember ENCLOSING and SUPER.  */
3545
3546 static tree
3547 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3548                      tree *super, tree class_type)
3549 {
3550   tree local_enclosing = *enclosing;
3551   tree local_super = NULL_TREE;
3552
3553   while (local_enclosing)
3554     {
3555       tree intermediate, decl;
3556
3557       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3558         local_enclosing;
3559
3560       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3561         return decl;
3562
3563       intermediate = local_enclosing;
3564       /* Explore enclosing contexts. */
3565       while (INNER_CLASS_DECL_P (intermediate))
3566         {
3567           intermediate = DECL_CONTEXT (intermediate);
3568           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3569             return decl;
3570         }
3571
3572       /* Now go to the upper classes, bail out if necessary.  We will
3573          analyze the returned SUPER and act accordingly (see
3574          do_resolve_class).  */
3575       if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3576           || TREE_TYPE (local_enclosing) == void_type_node)
3577         {
3578           parse_error_context (cl, "Qualifier must be a reference");
3579           local_enclosing = NULL_TREE;
3580           break;
3581         }
3582       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3583       if (!local_super || local_super == object_type_node)
3584         break;
3585
3586       if (TREE_CODE (local_super) == POINTER_TYPE)
3587         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3588       else
3589         local_super = TYPE_NAME (local_super);
3590
3591       /* We may not have checked for circular inheritance yet, so do so
3592          here to prevent an infinite loop. */
3593       if (htab_find (circularity_hash, local_super) != NULL)
3594         {
3595           if (!cl)
3596             cl = lookup_cl (local_enclosing);
3597
3598           parse_error_context
3599             (cl, "Cyclic inheritance involving %s",
3600              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3601           local_enclosing = NULL_TREE;
3602         }
3603       else
3604         local_enclosing = local_super;
3605     }
3606
3607   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3608   *super = local_super;
3609   *enclosing = local_enclosing;
3610
3611   return NULL_TREE;
3612 }
3613
3614 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3615    qualified. */
3616
3617 static tree
3618 find_as_inner_class (tree enclosing, tree name, tree cl)
3619 {
3620   tree qual, to_return;
3621   if (!enclosing)
3622     return NULL_TREE;
3623
3624   name = TYPE_NAME (name);
3625
3626   /* First search: within the scope of `enclosing', search for name */
3627   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3628     qual = EXPR_WFL_QUALIFICATION (cl);
3629   else if (cl)
3630     qual = build_tree_list (cl, NULL_TREE);
3631   else
3632     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3633
3634   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3635     return to_return;
3636
3637   /* We're dealing with a qualified name. Try to resolve thing until
3638      we get something that is an enclosing class. */
3639   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3640     {
3641       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3642
3643       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3644            qual = TREE_CHAIN (qual))
3645         {
3646           acc = merge_qualified_name (acc,
3647                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3648           BUILD_PTR_FROM_NAME (ptr, acc);
3649           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3650         }
3651
3652       /* A NULL qual and a decl means that the search ended
3653          successfully?!? We have to do something then. FIXME */
3654
3655       if (decl)
3656         enclosing = decl;
3657       else
3658         qual = EXPR_WFL_QUALIFICATION (cl);
3659     }
3660   /* Otherwise, create a qual for the other part of the resolution. */
3661   else
3662     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3663
3664   return find_as_inner_class_do (qual, enclosing);
3665 }
3666
3667 /* We go inside the list of sub classes and try to find a way
3668    through. */
3669
3670 static tree
3671 find_as_inner_class_do (tree qual, tree enclosing)
3672 {
3673   if (!qual)
3674     return NULL_TREE;
3675
3676   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3677     {
3678       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3679       tree next_enclosing = NULL_TREE;
3680       tree inner_list;
3681
3682       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3683            inner_list; inner_list = TREE_CHAIN (inner_list))
3684         {
3685           if (TREE_VALUE (inner_list) == name_to_match)
3686             {
3687               next_enclosing = TREE_PURPOSE (inner_list);
3688               break;
3689             }
3690         }
3691       enclosing = next_enclosing;
3692     }
3693
3694   return (!qual && enclosing ? enclosing : NULL_TREE);
3695 }
3696
3697 /* Reach all inner classes and tie their unqualified name to a
3698    DECL. */
3699
3700 static void
3701 set_nested_class_simple_name_value (tree outer, int set)
3702 {
3703   tree l;
3704
3705   for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
3706     IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
3707                                                 TREE_PURPOSE (l) : NULL_TREE);
3708 }
3709
3710 static void
3711 link_nested_class_to_enclosing (void)
3712 {
3713   if (GET_ENCLOSING_CPC ())
3714     {
3715       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3716       DECL_INNER_CLASS_LIST (enclosing) =
3717         tree_cons (GET_CPC (), GET_CPC_UN (),
3718                    DECL_INNER_CLASS_LIST (enclosing));
3719     }
3720 }
3721
3722 static tree
3723 maybe_make_nested_class_name (tree name)
3724 {
3725   tree id = NULL_TREE;
3726
3727   if (CPC_INNER_P ())
3728     {
3729       /* If we're in a function, we must append a number to create the
3730          nested class name.  However, we don't do this if the class we
3731          are constructing is anonymous, because in that case we'll
3732          already have a number as the class name.  */
3733       if (! make_nested_class_name (GET_CPC_LIST ())
3734           && current_function_decl != NULL_TREE
3735           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3736         {
3737           char buf[10];
3738           sprintf (buf, "%d", anonymous_class_counter);
3739           ++anonymous_class_counter;
3740           obstack_grow (&temporary_obstack, buf, strlen (buf));
3741           obstack_1grow (&temporary_obstack, '$');
3742         }
3743       obstack_grow0 (&temporary_obstack,
3744                      IDENTIFIER_POINTER (name),
3745                      IDENTIFIER_LENGTH (name));
3746       id = get_identifier (obstack_finish (&temporary_obstack));
3747       if (ctxp->package)
3748         QUALIFIED_P (id) = 1;
3749     }
3750   return id;
3751 }
3752
3753 /* If DECL is NULL, create and push a new DECL, record the current
3754    line CL and do other maintenance things.  */
3755
3756 static tree
3757 maybe_create_class_interface_decl (tree decl, tree raw_name,
3758                                    tree qualified_name, tree cl)
3759 {
3760   if (!decl)
3761     decl = push_class (make_class (), qualified_name);
3762
3763   /* Take care of the file and line business */
3764   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3765   /* If we're emitting xrefs, store the line/col number information */
3766   if (flag_emit_xref)
3767     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3768   else
3769     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3770   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3771   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3772   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3773     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3774
3775   PUSH_CPC (decl, raw_name);
3776   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3777
3778   /* Link the declaration to the already seen ones */
3779   TREE_CHAIN (decl) = ctxp->class_list;
3780   ctxp->class_list = decl;
3781
3782   /* Create a new nodes in the global lists */
3783   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3784   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3785
3786   /* Install a new dependency list element */
3787   create_jdep_list (ctxp);
3788
3789   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3790                           IDENTIFIER_POINTER (qualified_name)));
3791   return decl;
3792 }
3793
3794 static void
3795 add_superinterfaces (tree decl, tree interface_list)
3796 {
3797   tree node;
3798   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3799      takes care of ensuring that:
3800        - This is an accessible interface type,
3801        - Circularity detection.
3802    parser_add_interface is then called. If present but not defined,
3803    the check operation is delayed until the super interface gets
3804    defined.  */
3805   for (node = interface_list; node; node = TREE_CHAIN (node))
3806     {
3807       tree current = TREE_PURPOSE (node);
3808       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3809       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3810         {
3811           if (!parser_check_super_interface (idecl, decl, current))
3812             parser_add_interface (decl, idecl, current);
3813         }
3814       else
3815         register_incomplete_type (JDEP_INTERFACE,
3816                                   current, decl, NULL_TREE);
3817     }
3818 }
3819
3820 /* Create an interface in pass1 and return its decl. Return the
3821    interface's decl in pass 2.  */
3822
3823 static tree
3824 create_interface (int flags, tree id, tree super)
3825 {
3826   tree raw_name = EXPR_WFL_NODE (id);
3827   tree q_name = parser_qualified_classname (raw_name);
3828   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3829
3830   /* Certain syntax errors are making SUPER be like ID. Avoid this
3831      case. */
3832   if (ctxp->class_err && id == super)
3833     super = NULL;
3834
3835   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3836
3837   /* Basic checks: scope, redefinition, modifiers */
3838   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3839     {
3840       PUSH_ERROR ();
3841       return NULL_TREE;
3842     }
3843
3844   /* Suspend the current parsing context if we're parsing an inner
3845      interface */
3846   if (CPC_INNER_P ())
3847     {
3848       java_parser_context_suspend ();
3849       /* Interface members are public. */
3850       if (CLASS_INTERFACE (GET_CPC ()))
3851         flags |= ACC_PUBLIC;
3852     }
3853
3854   /* Push a new context for (static) initialized upon declaration fields */
3855   java_parser_context_push_initialized_field ();
3856
3857   /* Interface modifiers check
3858        - public/abstract allowed (already done at that point)
3859        - abstract is obsolete (comes first, it's a warning, or should be)
3860        - Can't use twice the same (checked in the modifier rule) */
3861   if ((flags & ACC_ABSTRACT) && flag_redundant)
3862     parse_warning_context
3863       (MODIFIER_WFL (ABSTRACT_TK),
3864        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3865
3866   /* Create a new decl if DECL is NULL, otherwise fix it */
3867   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3868
3869   /* Set super info and mark the class a complete */
3870   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3871                   object_type_node, ctxp->interface_number);
3872   ctxp->interface_number = 0;
3873   CLASS_COMPLETE_P (decl) = 1;
3874   add_superinterfaces (decl, super);
3875
3876   /* Eventually sets the @deprecated tag flag */
3877   CHECK_DEPRECATED (decl);
3878
3879   return decl;
3880 }
3881
3882 /* Patch anonymous class CLASS, by either extending or implementing
3883    DEP.  */
3884
3885 static void
3886 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
3887 {
3888   tree class = TREE_TYPE (class_decl);
3889   tree type =  TREE_TYPE (type_decl);
3890   tree binfo = TYPE_BINFO (class);
3891
3892   /* If it's an interface, implement it */
3893   if (CLASS_INTERFACE (type_decl))
3894     {
3895       tree s_binfo;
3896       int length;
3897
3898       if (parser_check_super_interface (type_decl, class_decl, wfl))
3899         return;
3900
3901       s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3902       length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3903       TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3904       TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3905       /* And add the interface */
3906       parser_add_interface (class_decl, type_decl, wfl);
3907     }
3908   /* Otherwise, it's a type we want to extend */
3909   else
3910     {
3911       if (parser_check_super (type_decl, class_decl, wfl))
3912         return;
3913       BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3914     }
3915 }
3916
3917 static tree
3918 create_anonymous_class (int location, tree type_name)
3919 {
3920   char buffer [80];
3921   tree super = NULL_TREE, itf = NULL_TREE;
3922   tree id, type_decl, class;
3923
3924   /* The unqualified name of the anonymous class. It's just a number. */
3925   sprintf (buffer, "%d", anonymous_class_counter++);
3926   id = build_wfl_node (get_identifier (buffer));
3927   EXPR_WFL_LINECOL (id) = location;
3928
3929   /* We know about the type to extend/implement. We go ahead */
3930   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3931     {
3932       /* Create a class which either implements on extends the designated
3933          class. The class bears an inaccessible name. */
3934       if (CLASS_INTERFACE (type_decl))
3935         {
3936           /* It's OK to modify it here. It's been already used and
3937              shouldn't be reused */
3938           ctxp->interface_number = 1;
3939           /* Interfaces should presented as a list of WFLs */
3940           itf = build_tree_list (type_name, NULL_TREE);
3941         }
3942       else
3943         super = type_name;
3944     }
3945
3946   class = create_class (ACC_FINAL, id, super, itf);
3947
3948   /* We didn't know anything about the stuff. We register a dependence. */
3949   if (!type_decl)
3950     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3951
3952   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3953   return class;
3954 }
3955
3956 /* Create a class in pass1 and return its decl. Return class
3957    interface's decl in pass 2.  */
3958
3959 static tree
3960 create_class (int flags, tree id, tree super, tree interfaces)
3961 {
3962   tree raw_name = EXPR_WFL_NODE (id);
3963   tree class_id, decl;
3964   tree super_decl_type;
3965
3966   /* Certain syntax errors are making SUPER be like ID. Avoid this
3967      case. */
3968   if (ctxp->class_err && id == super)
3969     super = NULL;
3970
3971   class_id = parser_qualified_classname (raw_name);
3972   decl = IDENTIFIER_CLASS_VALUE (class_id);
3973   EXPR_WFL_NODE (id) = class_id;
3974
3975   /* Basic check: scope, redefinition, modifiers */
3976   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3977     {
3978       PUSH_ERROR ();
3979       return NULL_TREE;
3980     }
3981
3982   /* Suspend the current parsing context if we're parsing an inner
3983      class or an anonymous class. */
3984   if (CPC_INNER_P ())
3985     {
3986       java_parser_context_suspend ();
3987       /* Interface members are public. */
3988       if (CLASS_INTERFACE (GET_CPC ()))
3989         flags |= ACC_PUBLIC;
3990     }
3991
3992   /* Push a new context for (static) initialized upon declaration fields */
3993   java_parser_context_push_initialized_field ();
3994
3995   /* Class modifier check:
3996        - Allowed modifier (already done at that point)
3997        - abstract AND final forbidden
3998        - Public classes defined in the correct file */
3999   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
4000     parse_error_context
4001       (id, "Class `%s' can't be declared both abstract and final",
4002        IDENTIFIER_POINTER (raw_name));
4003
4004   /* Create a new decl if DECL is NULL, otherwise fix it */
4005   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
4006
4007   /* If SUPER exists, use it, otherwise use Object */
4008   if (super)
4009     {
4010       /* Can't extend java.lang.Object */
4011       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
4012         {
4013           parse_error_context (id, "Can't extend `java.lang.Object'");
4014           return NULL_TREE;
4015         }
4016
4017       super_decl_type =
4018         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4019     }
4020   else if (TREE_TYPE (decl) != object_type_node)
4021     super_decl_type = object_type_node;
4022   /* We're defining java.lang.Object */
4023   else
4024     super_decl_type = NULL_TREE;
4025
4026   /* A class nested in an interface is implicitly static. */
4027   if (INNER_CLASS_DECL_P (decl)
4028       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4029     {
4030       flags |= ACC_STATIC;
4031     }
4032
4033   /* Set super info and mark the class as complete. */
4034   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4035                   ctxp->interface_number);
4036   ctxp->interface_number = 0;
4037   CLASS_COMPLETE_P (decl) = 1;
4038   add_superinterfaces (decl, interfaces);
4039
4040   /* TYPE_VFIELD' is a compiler-generated field used to point to
4041      virtual function tables.  In gcj, every class has a common base
4042      virtual function table in java.lang.object.  */
4043   TYPE_VFIELD (TREE_TYPE (decl)) = TYPE_VFIELD (object_type_node);
4044
4045   /* Add the private this$<n> field, Replicate final locals still in
4046      scope as private final fields mangled like val$<local_name>.
4047      This doesn't not occur for top level (static) inner classes. */
4048   if (PURE_INNER_CLASS_DECL_P (decl))
4049     add_inner_class_fields (decl, current_function_decl);
4050
4051   /* If doing xref, store the location at which the inherited class
4052      (if any) was seen. */
4053   if (flag_emit_xref && super)
4054     DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4055
4056   /* Eventually sets the @deprecated tag flag */
4057   CHECK_DEPRECATED (decl);
4058
4059   /* Reset the anonymous class counter when declaring non inner classes */
4060   if (!INNER_CLASS_DECL_P (decl))
4061     anonymous_class_counter = 1;
4062
4063   return decl;
4064 }
4065
4066 /* End a class declaration: register the statements used to create
4067    finit$ and <clinit>, pop the current class and resume the prior
4068    parser context if necessary.  */
4069
4070 static void
4071 end_class_declaration (int resume)
4072 {
4073   /* If an error occurred, context weren't pushed and won't need to be
4074      popped by a resume. */
4075   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4076
4077   if (GET_CPC () != error_mark_node)
4078     dump_java_tree (TDI_class, GET_CPC ());
4079
4080   java_parser_context_pop_initialized_field ();
4081   POP_CPC ();
4082   if (resume && no_error_occurred)
4083     java_parser_context_resume ();
4084
4085   /* We're ending a class declaration, this is a good time to reset
4086      the interface cout. Note that might have been already done in
4087      create_interface, but if at that time an inner class was being
4088      dealt with, the interface count was reset in a context created
4089      for the sake of handling inner classes declaration. */
4090   ctxp->interface_number = 0;
4091 }
4092
4093 static void
4094 add_inner_class_fields (tree class_decl, tree fct_decl)
4095 {
4096   tree block, marker, f;
4097
4098   f = add_field (TREE_TYPE (class_decl),
4099                  build_current_thisn (TREE_TYPE (class_decl)),
4100                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4101                  ACC_PRIVATE);
4102   FIELD_THISN (f) = 1;
4103
4104   if (!fct_decl)
4105     return;
4106
4107   for (block = GET_CURRENT_BLOCK (fct_decl);
4108        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4109     {
4110       tree decl;
4111       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4112         {
4113           tree name, pname;
4114           tree wfl, init, list;
4115
4116           /* Avoid non final arguments. */
4117           if (!LOCAL_FINAL_P (decl))
4118             continue;
4119
4120           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4121           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4122           wfl = build_wfl_node (name);
4123           init = build_wfl_node (pname);
4124           /* Build an initialization for the field: it will be
4125              initialized by a parameter added to finit$, bearing a
4126              mangled name of the field itself (param$<n>.) The
4127              parameter is provided to finit$ by the constructor
4128              invoking it (hence the constructor will also feature a
4129              hidden parameter, set to the value of the outer context
4130              local at the time the inner class is created.)
4131
4132              Note: we take into account all possible locals that can
4133              be accessed by the inner class. It's actually not trivial
4134              to minimize these aliases down to the ones really
4135              used. One way to do that would be to expand all regular
4136              methods first, then finit$ to get a picture of what's
4137              used.  It works with the exception that we would have to
4138              go back on all constructor invoked in regular methods to
4139              have their invocation reworked (to include the right amount
4140              of alias initializer parameters.)
4141
4142              The only real way around, I think, is a first pass to
4143              identify locals really used in the inner class. We leave
4144              the flag FIELD_LOCAL_ALIAS_USED around for that future
4145              use.
4146
4147              On the other hand, it only affect local inner classes,
4148              whose constructors (and finit$ call) will be featuring
4149              unnecessary arguments. It's easy for a developer to keep
4150              this number of parameter down by using the `final'
4151              keyword only when necessary. For the time being, we can
4152              issue a warning on unnecessary finals. FIXME */
4153           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4154                                    wfl, init);
4155
4156           /* Register the field. The TREE_LIST holding the part
4157              initialized/initializer will be marked ARG_FINAL_P so
4158              that the created field can be marked
4159              FIELD_LOCAL_ALIAS. */
4160           list = build_tree_list (wfl, init);
4161           ARG_FINAL_P (list) = 1;
4162           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4163         }
4164     }
4165
4166   if (!CPC_INITIALIZER_STMT (ctxp))
4167     return;
4168
4169   /* If we ever registered an alias field, insert and marker to
4170      remember where the list ends. The second part of the list (the one
4171      featuring initialized fields) so it can be later reversed to
4172      enforce 8.5. The marker will be removed during that operation. */
4173   marker = build_tree_list (NULL_TREE, NULL_TREE);
4174   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4175   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4176 }
4177
4178 /* Can't use lookup_field () since we don't want to load the class and
4179    can't set the CLASS_LOADED_P flag */
4180
4181 static tree
4182 find_field (tree class, tree name)
4183 {
4184   tree decl;
4185   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4186     {
4187       if (DECL_NAME (decl) == name)
4188         return decl;
4189     }
4190   return NULL_TREE;
4191 }
4192
4193 /* Wrap around lookup_field that doesn't potentially upset the value
4194    of CLASS */
4195
4196 static tree
4197 lookup_field_wrapper (tree class, tree name)
4198 {
4199   tree type = class;
4200   tree decl = NULL_TREE;
4201   java_parser_context_save_global ();
4202
4203   /* Last chance: if we're within the context of an inner class, we
4204      might be trying to access a local variable defined in an outer
4205      context. We try to look for it now. */
4206   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4207     {
4208       tree new_name;
4209       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4210       decl = lookup_field (&type, new_name);
4211       if (decl && decl != error_mark_node)
4212         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4213     }
4214   if (!decl || decl == error_mark_node)
4215     {
4216       type = class;
4217       decl = lookup_field (&type, name);
4218     }
4219
4220   /* If the field still hasn't been found, try the next enclosing context. */
4221   if (!decl && INNER_CLASS_TYPE_P (class))
4222     {
4223       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4224       decl = lookup_field_wrapper (outer_type, name);
4225     }
4226
4227   java_parser_context_restore_global ();
4228   return decl == error_mark_node ? NULL : decl;
4229 }
4230
4231 /* Find duplicate field within the same class declarations and report
4232    the error. Returns 1 if a duplicated field was found, 0
4233    otherwise.  */
4234
4235 static int
4236 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4237 {
4238   /* This might be modified to work with method decl as well */
4239   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4240   if (decl)
4241     {
4242       char *t1 = xstrdup (purify_type_name
4243                          ((TREE_CODE (new_type) == POINTER_TYPE
4244                            && TREE_TYPE (new_type) == NULL_TREE) ?
4245                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4246                           lang_printable_name (new_type, 1)));
4247       /* The type may not have been completed by the time we report
4248          the error */
4249       char *t2 = xstrdup (purify_type_name
4250                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4251                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4252                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4253                           lang_printable_name (TREE_TYPE (decl), 1)));
4254       parse_error_context
4255         (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4256          t1, IDENTIFIER_POINTER (new_field_name),
4257          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4258          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4259       free (t1);
4260       free (t2);
4261       return 1;
4262     }
4263   return 0;
4264 }
4265
4266 /* Field registration routine. If TYPE doesn't exist, field
4267    declarations are linked to the undefined TYPE dependency list, to
4268    be later resolved in java_complete_class () */
4269
4270 static void
4271 register_fields (int flags, tree type, tree variable_list)
4272 {
4273   tree current, saved_type;
4274   tree class_type = NULL_TREE;
4275   int saved_lineno = input_line;
4276   int must_chain = 0;
4277   tree wfl = NULL_TREE;
4278
4279   if (GET_CPC ())
4280     class_type = TREE_TYPE (GET_CPC ());
4281
4282   if (!class_type || class_type == error_mark_node)
4283     return;
4284
4285   /* If we're adding fields to interfaces, those fields are public,
4286      static, final */
4287   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4288     {
4289       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4290                                  flags, ACC_PUBLIC, "interface field(s)");
4291       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4292                                  flags, ACC_STATIC, "interface field(s)");
4293       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4294                                  flags, ACC_FINAL, "interface field(s)");
4295       check_modifiers ("Illegal interface member modifier `%s'", flags,
4296                        INTERFACE_FIELD_MODIFIERS);
4297       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4298     }
4299
4300   /* Obtain a suitable type for resolution, if necessary */
4301   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4302
4303   /* If TYPE is fully resolved and we don't have a reference, make one */
4304   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4305
4306   for (current = variable_list, saved_type = type; current;
4307        current = TREE_CHAIN (current), type = saved_type)
4308     {
4309       tree real_type;
4310       tree field_decl;
4311       tree cl = TREE_PURPOSE (current);
4312       tree init = TREE_VALUE (current);
4313       tree current_name = EXPR_WFL_NODE (cl);
4314
4315       /* Can't declare non-final static fields in inner classes */
4316       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4317           && !(flags & ACC_FINAL))
4318         parse_error_context
4319           (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4320            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4321            lang_printable_name (class_type, 0));
4322
4323       /* Process NAME, as it may specify extra dimension(s) for it */
4324       type = build_array_from_name (type, wfl, current_name, &current_name);
4325
4326       /* Type adjustment. We may have just readjusted TYPE because
4327          the variable specified more dimensions. Make sure we have
4328          a reference if we can and don't have one already. Also
4329          change the name if we have an init. */
4330       if (type != saved_type)
4331         {
4332           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4333           if (init)
4334             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4335         }
4336
4337       real_type = GET_REAL_TYPE (type);
4338       /* Check for redeclarations */
4339       if (duplicate_declaration_error_p (current_name, real_type, cl))
4340         continue;
4341
4342       /* Set input_line to the line the field was found and create a
4343          declaration for it. Eventually sets the @deprecated tag flag. */
4344       if (flag_emit_xref)
4345         input_line = EXPR_WFL_LINECOL (cl);
4346       else
4347         input_line = EXPR_WFL_LINENO (cl);
4348       field_decl = add_field (class_type, current_name, real_type, flags);
4349       CHECK_DEPRECATED_NO_RESET (field_decl);
4350
4351       /* If the field denotes a final instance variable, then we
4352          allocate a LANG_DECL_SPECIFIC part to keep track of its
4353          initialization. We also mark whether the field was
4354          initialized upon its declaration. We don't do that if the
4355          created field is an alias to a final local. */
4356       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4357         {
4358           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4359           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4360         }
4361
4362       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4363          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4364          hide parameters to this inner class finit$ and
4365          constructors. It also means that the field isn't final per
4366          say. */
4367       if (ARG_FINAL_P (current))
4368         {
4369           FIELD_LOCAL_ALIAS (field_decl) = 1;
4370           FIELD_FINAL (field_decl) = 0;
4371         }
4372
4373       /* Check if we must chain. */
4374       if (must_chain)
4375         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4376
4377       /* If we have an initialization value tied to the field */
4378       if (init)
4379         {
4380           /* The field is declared static */
4381           if (flags & ACC_STATIC)
4382             {
4383               /* We include the field and its initialization part into
4384                  a list used to generate <clinit>. After <clinit> is
4385                  walked, field initializations will be processed and
4386                  fields initialized with known constants will be taken
4387                  out of <clinit> and have their DECL_INITIAL set
4388                  appropriately. */
4389               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4390               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4391               if (TREE_OPERAND (init, 1)
4392                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4393                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4394             }
4395           /* A non-static field declared with an immediate initialization is
4396              to be initialized in <init>, if any.  This field is remembered
4397              to be processed at the time of the generation of <init>. */
4398           else
4399             {
4400               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4401               SET_CPC_INITIALIZER_STMT (ctxp, init);
4402             }
4403           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4404           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4405         }
4406     }
4407
4408   CLEAR_DEPRECATED;
4409   input_line = saved_lineno;
4410 }
4411
4412 /* Generate finit$, using the list of initialized fields to populate
4413    its body. finit$'s parameter(s) list is adjusted to include the
4414    one(s) used to initialized the field(s) caching outer context
4415    local(s).  */
4416
4417 static tree
4418 generate_finit (tree class_type)
4419 {
4420   int count = 0;
4421   tree list = TYPE_FINIT_STMT_LIST (class_type);
4422   tree mdecl, current, parms;
4423
4424   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4425                                                   class_type, NULL_TREE,
4426                                                   &count);
4427   CRAFTED_PARAM_LIST_FIXUP (parms);
4428   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4429                                     finit_identifier_node, parms);
4430   fix_method_argument_names (parms, mdecl);
4431   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4432                        mdecl, NULL_TREE);
4433   DECL_FUNCTION_NAP (mdecl) = count;
4434   start_artificial_method_body (mdecl);
4435
4436   for (current = list; current; current = TREE_CHAIN (current))
4437     java_method_add_stmt (mdecl,
4438                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4439                                                 current));
4440   end_artificial_method_body (mdecl);
4441   return mdecl;
4442 }
4443
4444 /* Generate a function to run the instance initialization code. The
4445    private method is called `instinit$'. Unless we're dealing with an
4446    anonymous class, we determine whether all ctors of CLASS_TYPE
4447    declare a checked exception in their `throws' clause in order to
4448    see whether it's necessary to encapsulate the instance initializer
4449    statements in a try/catch/rethrow sequence.  */
4450
4451 static tree
4452 generate_instinit (tree class_type)
4453 {
4454   tree current;
4455   tree compound = NULL_TREE;
4456   tree parms = tree_cons (this_identifier_node,
4457                           build_pointer_type (class_type), end_params_node);
4458   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4459                                          void_type_node,
4460                                          instinit_identifier_node, parms);
4461
4462   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4463                        mdecl, NULL_TREE);
4464
4465   /* Gather all the statements in a compound */
4466   for (current = TYPE_II_STMT_LIST (class_type);
4467        current; current = TREE_CHAIN (current))
4468     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4469
4470   /* We need to encapsulate COMPOUND by a try/catch statement to
4471      rethrow exceptions that might occur in the instance initializer.
4472      We do that only if all ctors of CLASS_TYPE are set to catch a
4473      checked exception. This doesn't apply to anonymous classes (since
4474      they don't have declared ctors.) */
4475   if (!ANONYMOUS_CLASS_P (class_type) &&
4476       ctors_unchecked_throws_clause_p (class_type))
4477     {
4478       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4479                                              build1 (THROW_EXPR, NULL_TREE,
4480                                                      build_wfl_node (wpv_id)));
4481       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4482                                                       exception_type_node);
4483     }
4484
4485   start_artificial_method_body (mdecl);
4486   java_method_add_stmt (mdecl, compound);
4487   end_artificial_method_body (mdecl);
4488
4489   return mdecl;
4490 }
4491
4492 /* FIXME */
4493 static tree
4494 build_instinit_invocation (tree class_type)
4495 {
4496   tree to_return = NULL_TREE;
4497
4498   if (TYPE_II_STMT_LIST (class_type))
4499     {
4500       tree parm = build_tree_list (NULL_TREE,
4501                                    build_wfl_node (this_identifier_node));
4502       to_return =
4503         build_method_invocation (build_wfl_node (instinit_identifier_node),
4504                                  parm);
4505     }
4506   return to_return;
4507 }
4508
4509 /* Shared across method_declarator and method_header to remember the
4510    patch stage that was reached during the declaration of the method.
4511    A method DECL is built differently is there is no patch
4512    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4513    pending on the currently defined method.  */
4514
4515 static int patch_stage;
4516
4517 /* Check the method declaration and add the method to its current
4518    class.  If the argument list is known to contain incomplete types,
4519    the method is partially added and the registration will be resume
4520    once the method arguments resolved. If TYPE is NULL, we're dealing
4521    with a constructor.  */
4522
4523 static tree
4524 method_header (int flags, tree type, tree mdecl, tree throws)
4525 {
4526   tree type_wfl = NULL_TREE;
4527   tree meth_name = NULL_TREE;
4528   tree current, orig_arg, this_class = NULL;
4529   tree id, meth;
4530   int saved_lineno;
4531   int constructor_ok = 0, must_chain;
4532   int count;
4533
4534   if (mdecl == error_mark_node)
4535     return error_mark_node;
4536   meth = TREE_VALUE (mdecl);
4537   id = TREE_PURPOSE (mdecl);
4538
4539   check_modifiers_consistency (flags);
4540
4541   if (GET_CPC ())
4542     this_class = TREE_TYPE (GET_CPC ());
4543
4544   if (!this_class || this_class == error_mark_node)
4545     return NULL_TREE;
4546
4547   /* There are some forbidden modifiers for an abstract method and its
4548      class must be abstract as well.  */
4549   if (type && (flags & ACC_ABSTRACT))
4550     {
4551       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4552       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4553       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4554       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4555       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4556       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4557       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4558           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4559         parse_error_context
4560           (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4561            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4562            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4563     }
4564
4565   /* A native method can't be strictfp.  */
4566   if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4567     parse_error_context (id, "native method `%s' can't be strictfp",
4568                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4569   /* No such thing as a transient or volatile method.  */
4570   if ((flags & ACC_TRANSIENT))
4571     parse_error_context (id, "method `%s' can't be transient",
4572                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4573   if ((flags & ACC_VOLATILE))
4574     parse_error_context (id, "method `%s' can't be volatile",
4575                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4576
4577   /* Things to be checked when declaring a constructor */
4578   if (!type)
4579     {
4580       int ec = java_error_count;
4581       /* 8.6: Constructor declarations: we might be trying to define a
4582          method without specifying a return type. */
4583       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4584         parse_error_context
4585           (id, "Invalid method declaration, return type required");
4586       /* 8.6.3: Constructor modifiers */
4587       else
4588         {
4589           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4590           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4591           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4592           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4593           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4594           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4595         }
4596       /* If we found error here, we don't consider it's OK to tread
4597          the method definition as a constructor, for the rest of this
4598          function */
4599       if (ec == java_error_count)
4600         constructor_ok = 1;
4601     }
4602
4603   /* Method declared within the scope of an interface are implicitly
4604      abstract and public. Conflicts with other erroneously provided
4605      modifiers are checked right after. */
4606
4607   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4608     {
4609       /* If FLAGS isn't set because of a modifier, turn the
4610          corresponding modifier WFL to NULL so we issue a warning on
4611          the obsolete use of the modifier */
4612       if (!(flags & ACC_PUBLIC))
4613         MODIFIER_WFL (PUBLIC_TK) = NULL;
4614       if (!(flags & ACC_ABSTRACT))
4615         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4616       flags |= ACC_PUBLIC;
4617       flags |= ACC_ABSTRACT;
4618     }
4619
4620   /* Inner class can't declare static methods */
4621   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4622     {
4623       parse_error_context
4624         (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4625          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4626          lang_printable_name (this_class, 0));
4627     }
4628
4629   /* Modifiers context reset moved up, so abstract method declaration
4630      modifiers can be later checked.  */
4631
4632   /* Set constructor returned type to void and method name to <init>,
4633      unless we found an error identifier the constructor (in which
4634      case we retain the original name) */
4635   if (!type)
4636     {
4637       type = void_type_node;
4638       if (constructor_ok)
4639         meth_name = init_identifier_node;
4640     }
4641   else
4642     meth_name = EXPR_WFL_NODE (id);
4643
4644   /* Do the returned type resolution and registration if necessary */
4645   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4646
4647   if (meth_name)
4648     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4649   EXPR_WFL_NODE (id) = meth_name;
4650   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4651
4652   if (must_chain)
4653     {
4654       patch_stage = JDEP_METHOD_RETURN;
4655       register_incomplete_type (patch_stage, type_wfl, id, type);
4656       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4657     }
4658   else
4659     TREE_TYPE (meth) = type;
4660
4661   saved_lineno = input_line;
4662   /* When defining an abstract or interface method, the curly
4663      bracket at level 1 doesn't exist because there is no function
4664      body */
4665   input_line = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4666             EXPR_WFL_LINENO (id));
4667
4668   /* Remember the original argument list */
4669   orig_arg = TYPE_ARG_TYPES (meth);
4670
4671   if (patch_stage)              /* includes ret type and/or all args */
4672     {
4673       jdep *jdep;
4674       meth = add_method_1 (this_class, flags, meth_name, meth);
4675       /* Patch for the return type */
4676       if (patch_stage == JDEP_METHOD_RETURN)
4677         {
4678           jdep = CLASSD_LAST (ctxp->classd_list);
4679           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4680         }
4681       /* This is the stop JDEP. METH allows the function's signature
4682          to be computed. */
4683       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4684     }
4685   else
4686     meth = add_method (this_class, flags, meth_name,
4687                        build_java_signature (meth));
4688
4689   /* Remember final parameters */
4690   MARK_FINAL_PARMS (meth, orig_arg);
4691
4692   /* Fix the method argument list so we have the argument name
4693      information */
4694   fix_method_argument_names (orig_arg, meth);
4695
4696   /* Register the parameter number and re-install the current line
4697      number */
4698   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4699   input_line = saved_lineno;
4700
4701   /* Register exception specified by the `throws' keyword for
4702      resolution and set the method decl appropriate field to the list.
4703      Note: the grammar ensures that what we get here are class
4704      types. */
4705   if (throws)
4706     {
4707       throws = nreverse (throws);
4708       for (current = throws; current; current = TREE_CHAIN (current))
4709         {
4710           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4711                                     NULL_TREE, NULL_TREE);
4712           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4713             &TREE_VALUE (current);
4714         }
4715       DECL_FUNCTION_THROWS (meth) = throws;
4716     }
4717
4718   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4719     DECL_FUNCTION_WFL (meth) = id;
4720
4721   /* Set the flag if we correctly processed a constructor */
4722   if (constructor_ok)
4723     {
4724       DECL_CONSTRUCTOR_P (meth) = 1;
4725       /* Compute and store the number of artificial parameters declared
4726          for this constructor */
4727       for (count = 0, current = TYPE_FIELDS (this_class); current;
4728            current = TREE_CHAIN (current))
4729         if (FIELD_LOCAL_ALIAS (current))
4730           count++;
4731       DECL_FUNCTION_NAP (meth) = count;
4732     }
4733
4734   /* Eventually set the @deprecated tag flag */
4735   CHECK_DEPRECATED (meth);
4736
4737   /* If doing xref, store column and line number information instead
4738      of the line number only. */
4739   if (flag_emit_xref)
4740     DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4741
4742   return meth;
4743 }
4744
4745 static void
4746 fix_method_argument_names (tree orig_arg, tree meth)
4747 {
4748   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4749   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4750     {
4751       TREE_PURPOSE (arg) = this_identifier_node;
4752       arg = TREE_CHAIN (arg);
4753     }
4754   while (orig_arg != end_params_node)
4755     {
4756       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4757       orig_arg = TREE_CHAIN (orig_arg);
4758       arg = TREE_CHAIN (arg);
4759     }
4760 }
4761
4762 /* Complete the method declaration with METHOD_BODY.  */
4763
4764 static void
4765 finish_method_declaration (tree method_body)
4766 {
4767   int flags;
4768
4769   if (!current_function_decl)
4770     return;
4771
4772   flags = get_access_flags_from_decl (current_function_decl);
4773
4774   /* 8.4.5 Method Body */
4775   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4776     {
4777       tree name = DECL_NAME (current_function_decl);
4778       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4779                            "%s method `%s' can't have a body defined",
4780                            (METHOD_NATIVE (current_function_decl) ?
4781                             "Native" : "Abstract"),
4782                            IDENTIFIER_POINTER (name));
4783       method_body = NULL_TREE;
4784     }
4785   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4786     {
4787       tree name = DECL_NAME (current_function_decl);
4788       parse_error_context
4789         (DECL_FUNCTION_WFL (current_function_decl),
4790          "Non native and non abstract method `%s' must have a body defined",
4791          IDENTIFIER_POINTER (name));
4792       method_body = NULL_TREE;
4793     }
4794
4795   if (flag_emit_class_files && method_body
4796       && TREE_CODE (method_body) == NOP_EXPR
4797       && TREE_TYPE (current_function_decl)
4798       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4799     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4800
4801   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4802   maybe_absorb_scoping_blocks ();
4803   /* Exit function's body */
4804   exit_block ();
4805   /* Merge last line of the function with first line, directly in the
4806      function decl. It will be used to emit correct debug info. */
4807   if (!flag_emit_xref)
4808     DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4809
4810   /* Since function's argument's list are shared, reset the
4811      ARG_FINAL_P parameter that might have been set on some of this
4812      function parameters. */
4813   UNMARK_FINAL_PARMS (current_function_decl);
4814
4815   /* So we don't have an irrelevant function declaration context for
4816      the next static block we'll see. */
4817   current_function_decl = NULL_TREE;
4818 }
4819
4820 /* Build a an error message for constructor circularity errors.  */
4821
4822 static char *
4823 constructor_circularity_msg (tree from, tree to)
4824 {
4825   static char string [4096];
4826   char *t = xstrdup (lang_printable_name (from, 0));
4827   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4828   free (t);
4829   return string;
4830 }
4831
4832 /* Verify a circular call to METH. Return 1 if an error is found, 0
4833    otherwise.  */
4834
4835 static GTY(()) tree vcc_list;
4836 static int
4837 verify_constructor_circularity (tree meth, tree current)
4838 {
4839   tree c;
4840
4841   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4842     {
4843       if (TREE_VALUE (c) == meth)
4844         {
4845           char *t;
4846           if (vcc_list)
4847             {
4848               tree liste;
4849               vcc_list = nreverse (vcc_list);
4850               for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4851                 {
4852                   parse_error_context
4853                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4854                      constructor_circularity_msg
4855                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4856                   java_error_count--;
4857                 }
4858             }
4859           t = xstrdup (lang_printable_name (meth, 0));
4860           parse_error_context (TREE_PURPOSE (c),
4861                                "%s: recursive invocation of constructor `%s'",
4862                                constructor_circularity_msg (current, meth), t);
4863           free (t);
4864           vcc_list = NULL_TREE;
4865           return 1;
4866         }
4867     }
4868   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4869     {
4870       vcc_list = tree_cons (c, current, vcc_list);
4871       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4872         return 1;
4873       vcc_list = TREE_CHAIN (vcc_list);
4874     }
4875   return 0;
4876 }
4877
4878 /* Check modifiers that can be declared but exclusively */
4879
4880 static void
4881 check_modifiers_consistency (int flags)
4882 {
4883   int acc_count = 0;
4884   tree cl = NULL_TREE;
4885
4886   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4887   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4888   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4889   if (acc_count > 1)
4890     parse_error_context
4891       (cl, "Inconsistent member declaration.  At most one of `public', `private', or `protected' may be specified");
4892
4893   acc_count = 0;
4894   cl = NULL_TREE;
4895   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4896   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4897   if (acc_count > 1)
4898     parse_error_context (cl,
4899                          "Inconsistent member declaration.  At most one of `final' or `volatile' may be specified");
4900 }
4901
4902 /* Check the methode header METH for abstract specifics features */
4903
4904 static void
4905 check_abstract_method_header (tree meth)
4906 {
4907   int flags = get_access_flags_from_decl (meth);
4908
4909   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4910                               ACC_ABSTRACT, "abstract method",
4911                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4912   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4913                               ACC_PUBLIC, "abstract method",
4914                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4915
4916   check_modifiers ("Illegal modifier `%s' for interface method",
4917                   flags, INTERFACE_METHOD_MODIFIERS);
4918 }
4919
4920 /* Create a FUNCTION_TYPE node and start augmenting it with the
4921    declared function arguments. Arguments type that can't be resolved
4922    are left as they are, but the returned node is marked as containing
4923    incomplete types.  */
4924
4925 static tree
4926 method_declarator (tree id, tree list)
4927 {
4928   tree arg_types = NULL_TREE, current, node;
4929   tree meth = make_node (FUNCTION_TYPE);
4930   jdep *jdep;
4931
4932   patch_stage = JDEP_NO_PATCH;
4933
4934   if (GET_CPC () == error_mark_node)
4935     return error_mark_node;
4936
4937   /* If we're dealing with an inner class constructor, we hide the
4938      this$<n> decl in the name field of its parameter declaration.  We
4939      also might have to hide the outer context local alias
4940      initializers. Not done when the class is a toplevel class. */
4941   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4942       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4943     {
4944       tree aliases_list, type, thisn;
4945       /* First the aliases, linked to the regular parameters */
4946       aliases_list =
4947         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4948                                                 TREE_TYPE (GET_CPC ()),
4949                                                 NULL_TREE, NULL);
4950       list = chainon (nreverse (aliases_list), list);
4951
4952       /* Then this$<n> */
4953       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4954       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4955       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4956                         list);
4957     }
4958
4959   for (current = list; current; current = TREE_CHAIN (current))
4960     {
4961       int must_chain = 0;
4962       tree wfl_name = TREE_PURPOSE (current);
4963       tree type = TREE_VALUE (current);
4964       tree name = EXPR_WFL_NODE (wfl_name);
4965       tree already, arg_node;
4966       tree type_wfl = NULL_TREE;
4967       tree real_type;
4968
4969       /* Obtain a suitable type for resolution, if necessary */
4970       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4971
4972       /* Process NAME, as it may specify extra dimension(s) for it */
4973       type = build_array_from_name (type, type_wfl, name, &name);
4974       EXPR_WFL_NODE (wfl_name) = name;
4975
4976       real_type = GET_REAL_TYPE (type);
4977       if (TREE_CODE (real_type) == RECORD_TYPE)
4978         {
4979           real_type = promote_type (real_type);
4980           if (TREE_CODE (type) == TREE_LIST)
4981             TREE_PURPOSE (type) = real_type;
4982         }
4983
4984       /* Check redefinition */
4985       for (already = arg_types; already; already = TREE_CHAIN (already))
4986         if (TREE_PURPOSE (already) == name)
4987           {
4988             parse_error_context
4989               (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4990                IDENTIFIER_POINTER (name),
4991                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4992             break;
4993           }
4994
4995       /* If we've an incomplete argument type, we know there is a location
4996          to patch when the type get resolved, later.  */
4997       jdep = NULL;
4998       if (must_chain)
4999         {
5000           patch_stage = JDEP_METHOD;
5001           type = register_incomplete_type (patch_stage,
5002                                            type_wfl, wfl_name, type);
5003           jdep = CLASSD_LAST (ctxp->classd_list);
5004           JDEP_MISC (jdep) = id;
5005         }
5006
5007       /* The argument node: a name and a (possibly) incomplete type.  */
5008       arg_node = build_tree_list (name, real_type);
5009       /* Remember arguments declared final. */
5010       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
5011
5012       if (jdep)
5013         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
5014       TREE_CHAIN (arg_node) = arg_types;
5015       arg_types = arg_node;
5016     }
5017   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
5018   node = build_tree_list (id, meth);
5019   return node;
5020 }
5021
5022 static int
5023 unresolved_type_p (tree wfl, tree *returned)
5024
5025 {
5026   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5027     {
5028       if (returned)
5029         {
5030           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5031           if (decl && current_class && (decl == TYPE_NAME (current_class)))
5032             *returned = TREE_TYPE (decl);
5033           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5034             *returned = TREE_TYPE (GET_CPC ());
5035           else
5036             *returned = NULL_TREE;
5037         }
5038       return 1;
5039     }
5040   if (returned)
5041     *returned = wfl;
5042   return 0;
5043 }
5044
5045 /* From NAME, build a qualified identifier node using the
5046    qualification from the current package definition. */
5047
5048 static tree
5049 parser_qualified_classname (tree name)
5050 {
5051   tree nested_class_name;
5052
5053   if ((nested_class_name = maybe_make_nested_class_name (name)))
5054     return nested_class_name;
5055
5056   if (ctxp->package)
5057     return merge_qualified_name (ctxp->package, name);
5058   else
5059     return name;
5060 }
5061
5062 /* Called once the type a interface extends is resolved. Returns 0 if
5063    everything is OK.  */
5064
5065 static int
5066 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5067 {
5068   tree super_type = TREE_TYPE (super_decl);
5069
5070   /* Has to be an interface */
5071   if (!CLASS_INTERFACE (super_decl))
5072     {
5073       parse_error_context
5074         (this_wfl, "%s `%s' can't implement/extend %s `%s'",
5075          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5076           "Interface" : "Class"),
5077          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5078          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5079          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5080       return 1;
5081     }
5082
5083   /* Check top-level interface access. Inner classes are subject to member
5084      access rules (6.6.1). */
5085   if (! INNER_CLASS_P (super_type)
5086       && check_pkg_class_access (DECL_NAME (super_decl),
5087                                  NULL_TREE, true, this_decl))
5088     return 1;
5089
5090   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5091                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5092                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5093   return 0;
5094 }
5095
5096 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5097    0 if everything is OK.  */
5098
5099 static int
5100 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5101 {
5102   tree super_type = TREE_TYPE (super_decl);
5103
5104   /* SUPER should be a CLASS (neither an array nor an interface) */
5105   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5106     {
5107       parse_error_context
5108         (wfl, "Class `%s' can't subclass %s `%s'",
5109          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5110          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5111          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5112       return 1;
5113     }
5114
5115   if (CLASS_FINAL (TYPE_NAME (super_type)))
5116     {
5117       parse_error_context (wfl, "Can't subclass final classes: %s",
5118                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5119       return 1;
5120     }
5121
5122   /* Check top-level class scope. Inner classes are subject to member access
5123      rules (6.6.1). */
5124   if (! INNER_CLASS_P (super_type)
5125       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true, NULL_TREE)))
5126     return 1;
5127
5128   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5129                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5130                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5131   return 0;
5132 }
5133
5134 /* Create a new dependency list and link it (in a LIFO manner) to the
5135    CTXP list of type dependency list.  */
5136
5137 static void
5138 create_jdep_list (struct parser_ctxt *ctxp)
5139 {
5140   jdeplist *new = xmalloc (sizeof (jdeplist));
5141   new->first = new->last = NULL;
5142   new->next = ctxp->classd_list;
5143   ctxp->classd_list = new;
5144 }
5145
5146 static jdeplist *
5147 reverse_jdep_list (struct parser_ctxt *ctxp)
5148 {
5149   jdeplist *prev = NULL, *current, *next;
5150   for (current = ctxp->classd_list; current; current = next)
5151     {
5152       next = current->next;
5153       current->next = prev;
5154       prev = current;
5155     }
5156   return prev;
5157 }
5158
5159 /* Create a fake pointer based on the ID stored in
5160    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5161    registered again. */
5162
5163 static tree
5164 obtain_incomplete_type (tree type_name)
5165 {
5166   tree ptr = NULL_TREE, name;
5167
5168   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5169     name = EXPR_WFL_NODE (type_name);
5170   else if (INCOMPLETE_TYPE_P (type_name))
5171     name = TYPE_NAME (type_name);
5172   else
5173     abort ();
5174
5175   /* Workaround from build_pointer_type for incomplete types.  */
5176   BUILD_PTR_FROM_NAME (ptr, name);
5177   TYPE_MODE (ptr) = ptr_mode;
5178   layout_type (ptr);
5179
5180   return ptr;
5181 }
5182
5183 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5184    non NULL instead of computing a new fake type based on WFL. The new
5185    dependency is inserted in the current type dependency list, in FIFO
5186    manner.  */
5187
5188 static tree
5189 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5190 {
5191   jdep *new = xmalloc (sizeof (jdep));
5192
5193   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5194     ptr = obtain_incomplete_type (wfl);
5195
5196   JDEP_KIND (new) = kind;
5197   JDEP_DECL (new) = decl;
5198   JDEP_TO_RESOLVE (new) = ptr;
5199   JDEP_WFL (new) = wfl;
5200   JDEP_CHAIN (new) = NULL;
5201   JDEP_MISC (new) = NULL_TREE;
5202   /* For some dependencies, set the enclosing class of the current
5203      class to be the enclosing context */
5204   if ((kind == JDEP_INTERFACE  || kind == JDEP_ANONYMOUS)
5205       && GET_ENCLOSING_CPC ())
5206     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5207   else if (kind == JDEP_SUPER)
5208     JDEP_ENCLOSING (new) = (GET_ENCLOSING_CPC () ?
5209                             TREE_VALUE (GET_ENCLOSING_CPC ()) : NULL_TREE);
5210   else
5211     JDEP_ENCLOSING (new) = GET_CPC ();
5212   JDEP_GET_PATCH (new) = (tree *)NULL;
5213
5214   JDEP_INSERT (ctxp->classd_list, new);
5215
5216   return ptr;
5217 }
5218
5219 /* This checks for circular references with innerclasses. We start
5220    from SOURCE and should never reach TARGET. Extended/implemented
5221    types in SOURCE have their enclosing context checked not to reach
5222    TARGET. When the last enclosing context of SOURCE is reached, its
5223    extended/implemented types are also checked not to reach TARGET.
5224    In case of error, WFL of the offending type is returned; NULL_TREE
5225    otherwise.  */
5226
5227 static tree
5228 check_inner_circular_reference (tree source, tree target)
5229 {
5230   tree basetype_vec = TYPE_BINFO_BASETYPES (source);
5231   tree ctx, cl;
5232   int i;
5233
5234   if (!basetype_vec)
5235     return NULL_TREE;
5236
5237   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5238     {
5239       tree su;
5240
5241       /* We can end up with a NULL_TREE or an incomplete type here if
5242          we encountered previous type resolution errors. It's safe to
5243          simply ignore these cases.  */
5244       if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
5245         continue;
5246       su = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
5247       if (INCOMPLETE_TYPE_P (su))
5248         continue;
5249
5250       if (inherits_from_p (su, target))
5251         return lookup_cl (TYPE_NAME (su));
5252
5253       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5254         {
5255           /* An enclosing context shouldn't be TARGET */
5256           if (ctx == TYPE_NAME (target))
5257             return lookup_cl (TYPE_NAME (su));
5258
5259           /* When we reach the enclosing last context, start a check
5260              on it, with the same target */
5261           if (! DECL_CONTEXT (ctx) &&
5262               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5263             return cl;
5264         }
5265     }
5266   return NULL_TREE;
5267 }
5268
5269 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5270    offending type if a circularity is detected. NULL_TREE is returned
5271    otherwise. TYPE can be an interface or a class.   */
5272
5273 static tree
5274 check_circular_reference (tree type)
5275 {
5276   tree basetype_vec = TYPE_BINFO_BASETYPES (type);
5277   int i;
5278
5279   if (!basetype_vec)
5280     return NULL_TREE;
5281
5282   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5283     {
5284       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5285         return lookup_cl (TYPE_NAME (type));
5286       return NULL_TREE;
5287     }
5288
5289   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5290     {
5291       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
5292       if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
5293           && interface_of_p (type, BINFO_TYPE (vec_elt)))
5294         return lookup_cl (TYPE_NAME (BINFO_TYPE (vec_elt)));
5295     }
5296   return NULL_TREE;
5297 }
5298
5299 void
5300 java_check_circular_reference (void)
5301 {
5302   tree current;
5303   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5304     {
5305       tree type = TREE_TYPE (current);
5306       tree cl;
5307
5308       cl = check_circular_reference (type);
5309       if (! cl)
5310         cl = check_inner_circular_reference (type, type);
5311       if (cl)
5312         parse_error_context (cl, "Cyclic class inheritance%s",
5313                              (cyclic_inheritance_report ?
5314                               cyclic_inheritance_report : ""));
5315     }
5316 }
5317
5318 /* Augment the parameter list PARM with parameters crafted to
5319    initialize outer context locals aliases. Through ARTIFICIAL, a
5320    count is kept of the number of crafted parameters. MODE governs
5321    what eventually gets created: something suitable for a function
5322    creation or a function invocation, either the constructor or
5323    finit$.  */
5324
5325 static tree
5326 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5327                                         int *artificial)
5328 {
5329   tree field;
5330   tree additional_parms = NULL_TREE;
5331
5332   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5333     if (FIELD_LOCAL_ALIAS (field))
5334       {
5335         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5336         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5337         tree mangled_id;
5338
5339         switch (mode)
5340           {
5341           case AIPL_FUNCTION_DECLARATION:
5342             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5343                                                          &buffer [4]);
5344             purpose = build_wfl_node (mangled_id);
5345             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5346               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5347             else
5348               value = TREE_TYPE (field);
5349             break;
5350
5351           case AIPL_FUNCTION_CREATION:
5352             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5353                                                          &buffer [4]);
5354             value = TREE_TYPE (field);
5355             break;
5356
5357           case AIPL_FUNCTION_FINIT_INVOCATION:
5358             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5359                                                          &buffer [4]);
5360             /* Now, this is wrong. purpose should always be the NAME
5361                of something and value its matching value (decl, type,
5362                etc...) FIXME -- but there is a lot to fix. */
5363
5364             /* When invoked for this kind of operation, we already
5365                know whether a field is used or not. */
5366             purpose = TREE_TYPE (field);
5367             value = build_wfl_node (mangled_id);
5368             break;
5369
5370           case AIPL_FUNCTION_CTOR_INVOCATION:
5371             /* There are two case: the constructor invocation happens
5372                outside the local inner, in which case, locales from the outer
5373                context are directly used.
5374
5375                Otherwise, we fold to using the alias directly. */
5376             if (class_type == current_class)
5377               value = field;
5378             else
5379               {
5380                 name = get_identifier (&buffer[4]);
5381                 value = IDENTIFIER_LOCAL_VALUE (name);
5382               }
5383             break;
5384           }
5385         additional_parms = tree_cons (purpose, value, additional_parms);
5386         if (artificial)
5387           *artificial +=1;
5388       }
5389   if (additional_parms)
5390     {
5391       if (ANONYMOUS_CLASS_P (class_type)
5392           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5393         additional_parms = nreverse (additional_parms);
5394       parm = chainon (additional_parms, parm);
5395     }
5396
5397    return parm;
5398 }
5399
5400 /* Craft a constructor for CLASS_DECL -- what we should do when none
5401    where found. ARGS is non NULL when a special signature must be
5402    enforced. This is the case for anonymous classes.  */
5403
5404 static tree
5405 craft_constructor (tree class_decl, tree args)
5406 {
5407   tree class_type = TREE_TYPE (class_decl);
5408   tree parm = NULL_TREE;
5409   int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5410                ACC_PUBLIC : 0);
5411   int i = 0, artificial = 0;
5412   tree decl, ctor_name;
5413   char buffer [80];
5414
5415   /* The constructor name is <init> unless we're dealing with an
5416      anonymous class, in which case the name will be fixed after having
5417      be expanded. */
5418   if (ANONYMOUS_CLASS_P (class_type))
5419     ctor_name = DECL_NAME (class_decl);
5420   else
5421     ctor_name = init_identifier_node;
5422
5423   /* If we're dealing with an inner class constructor, we hide the
5424      this$<n> decl in the name field of its parameter declaration. */
5425   if (PURE_INNER_CLASS_TYPE_P (class_type))
5426     {
5427       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5428       parm = tree_cons (build_current_thisn (class_type),
5429                         build_pointer_type (type), parm);
5430
5431       /* Some more arguments to be hidden here. The values of the local
5432          variables of the outer context that the inner class needs to see. */
5433       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5434                                                      class_type, parm,
5435                                                      &artificial);
5436     }
5437
5438   /* Then if there are any args to be enforced, enforce them now */
5439   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5440     {
5441       sprintf (buffer, "parm%d", i++);
5442       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5443     }
5444
5445   CRAFTED_PARAM_LIST_FIXUP (parm);
5446   decl = create_artificial_method (class_type, flags, void_type_node,
5447                                    ctor_name, parm);
5448   fix_method_argument_names (parm, decl);
5449   /* Now, mark the artificial parameters. */
5450   DECL_FUNCTION_NAP (decl) = artificial;
5451   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5452   DECL_INLINE (decl) = 1;
5453   return decl;
5454 }
5455
5456
5457 /* Fix the constructors. This will be called right after circular
5458    references have been checked. It is necessary to fix constructors
5459    early even if no code generation will take place for that class:
5460    some generated constructor might be required by the class whose
5461    compilation triggered this one to be simply loaded.  */
5462
5463 void
5464 java_fix_constructors (void)
5465 {
5466   tree current;
5467
5468   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5469     {
5470       tree class_type = TREE_TYPE (current);
5471       int saw_ctor = 0;
5472       tree decl;
5473
5474       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5475         continue;
5476
5477       output_class = current_class = class_type;
5478       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5479         {
5480           if (DECL_CONSTRUCTOR_P (decl))
5481             {
5482               fix_constructors (decl);
5483               saw_ctor = 1;
5484             }
5485         }
5486
5487       /* Anonymous class constructor can't be generated that early. */
5488       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5489         craft_constructor (current, NULL_TREE);
5490     }
5491 }
5492
5493 /* safe_layout_class just makes sure that we can load a class without
5494    disrupting the current_class, input_file, input_line, etc, information
5495    about the class processed currently.  */
5496
5497 void
5498 safe_layout_class (tree class)
5499 {
5500   tree save_current_class = current_class;
5501   location_t save_location = input_location;
5502
5503   layout_class (class);
5504
5505   current_class = save_current_class;
5506   input_location = save_location;
5507 }
5508
5509 static tree
5510 jdep_resolve_class (jdep *dep)
5511 {
5512   tree decl;
5513
5514   if (JDEP_RESOLVED_P (dep))
5515     decl = JDEP_RESOLVED_DECL (dep);
5516   else
5517     {
5518       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5519                             JDEP_DECL (dep), JDEP_WFL (dep));
5520       JDEP_RESOLVED (dep, decl);
5521       /* If there is no WFL, that's ok.  We generate this warning
5522          elsewhere.  */
5523       if (decl && JDEP_WFL (dep) != NULL_TREE)
5524         check_deprecation (JDEP_WFL (dep), decl);
5525     }
5526
5527   if (!decl)
5528     complete_class_report_errors (dep);
5529   else if (PURE_INNER_CLASS_DECL_P (decl))
5530     {
5531       tree inner = TREE_TYPE (decl);
5532       if (! CLASS_LOADED_P (inner))
5533         {
5534           safe_layout_class (inner);
5535           if (TYPE_SIZE (inner) == error_mark_node)
5536             TYPE_SIZE (inner) = NULL_TREE;
5537         }
5538       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5539     }
5540   return decl;
5541 }
5542
5543 /* Complete unsatisfied class declaration and their dependencies */
5544
5545 void
5546 java_complete_class (void)
5547 {
5548   tree cclass;
5549   jdeplist *cclassd;
5550   int error_found;
5551   tree type;
5552
5553   /* Process imports */
5554   process_imports ();
5555
5556   /* Reverse things so we have the right order */
5557   ctxp->class_list = nreverse (ctxp->class_list);
5558   ctxp->classd_list = reverse_jdep_list (ctxp);
5559
5560   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5561        cclass && cclassd;
5562        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5563     {
5564       jdep *dep;
5565
5566       /* We keep the compilation unit imports in the class so that
5567          they can be used later to resolve type dependencies that
5568          aren't necessary to solve now. */
5569       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5570       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5571
5572       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5573         {
5574           tree decl;
5575           if (!(decl = jdep_resolve_class (dep)))
5576             continue;
5577
5578           /* Now it's time to patch */
5579           switch (JDEP_KIND (dep))
5580             {
5581             case JDEP_SUPER:
5582               /* Simply patch super */
5583               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5584                 continue;
5585               BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5586                 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5587               break;
5588
5589             case JDEP_FIELD:
5590               {
5591                 /* We do part of the job done in add_field */
5592                 tree field_decl = JDEP_DECL (dep);
5593                 tree field_type = TREE_TYPE (decl);
5594                 if (TREE_CODE (field_type) == RECORD_TYPE)
5595                   field_type = promote_type (field_type);
5596                 TREE_TYPE (field_decl) = field_type;
5597                 DECL_ALIGN (field_decl) = 0;
5598                 DECL_USER_ALIGN (field_decl) = 0;
5599                 layout_decl (field_decl, 0);
5600                 SOURCE_FRONTEND_DEBUG
5601                   (("Completed field/var decl `%s' with `%s'",
5602                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5603                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5604                 break;
5605               }
5606             case JDEP_METHOD:   /* We start patching a method */
5607             case JDEP_METHOD_RETURN:
5608               error_found = 0;
5609               while (1)
5610                 {
5611                   if (decl)
5612                     {
5613                       type = TREE_TYPE(decl);
5614                       if (TREE_CODE (type) == RECORD_TYPE)
5615                         type = promote_type (type);
5616                       JDEP_APPLY_PATCH (dep, type);
5617                       SOURCE_FRONTEND_DEBUG
5618                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5619                            "Completing fct `%s' with ret type `%s'":
5620                            "Completing arg `%s' with type `%s'"),
5621                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5622                                               (JDEP_DECL_WFL (dep))),
5623                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5624                     }
5625                   else
5626                     error_found = 1;
5627                   dep = JDEP_CHAIN (dep);
5628                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5629                     break;
5630                   else
5631                     decl = jdep_resolve_class (dep);
5632                 }
5633               if (!error_found)
5634                 {
5635                   tree mdecl = JDEP_DECL (dep), signature;
5636                   /* Recompute and reset the signature, check first that
5637                      all types are now defined. If they're not,
5638                      don't build the signature. */
5639                   if (check_method_types_complete (mdecl))
5640                     {
5641                       signature = build_java_signature (TREE_TYPE (mdecl));
5642                       set_java_signature (TREE_TYPE (mdecl), signature);
5643                     }
5644                 }
5645               else
5646                 continue;
5647               break;
5648
5649             case JDEP_INTERFACE:
5650               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5651                                                 JDEP_WFL (dep)))
5652                 continue;
5653               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5654               break;
5655
5656             case JDEP_PARM:
5657             case JDEP_VARIABLE:
5658               type = TREE_TYPE(decl);
5659               if (TREE_CODE (type) == RECORD_TYPE)
5660                 type = promote_type (type);
5661               JDEP_APPLY_PATCH (dep, type);
5662               break;
5663
5664             case JDEP_TYPE:
5665               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5666               SOURCE_FRONTEND_DEBUG
5667                 (("Completing a random type dependency on a '%s' node",
5668                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5669               break;
5670
5671             case JDEP_EXCEPTION:
5672               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5673               SOURCE_FRONTEND_DEBUG
5674                 (("Completing `%s' `throws' argument node",
5675                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5676               break;
5677
5678             case JDEP_ANONYMOUS:
5679               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5680               break;
5681
5682             default:
5683               abort ();
5684             }
5685         }
5686     }
5687   return;
5688 }
5689
5690 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5691    array.  */
5692
5693 static tree
5694 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5695 {
5696   tree tname = TYPE_NAME (class_type);
5697   tree resolved_type = TREE_TYPE (class_type);
5698   int array_dims = 0;
5699   tree resolved_type_decl;
5700
5701   if (resolved_type != NULL_TREE)
5702     {
5703       tree resolved_type_decl = TYPE_NAME (resolved_type);
5704       if (resolved_type_decl == NULL_TREE
5705           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5706         {
5707           resolved_type_decl = build_decl (TYPE_DECL,
5708                                            TYPE_NAME (class_type),
5709                                            resolved_type);
5710         }
5711       return resolved_type_decl;
5712     }
5713
5714   /* 1- Check to see if we have an array. If true, find what we really
5715      want to resolve  */
5716   if ((array_dims = build_type_name_from_array_name (tname,
5717                                                      &TYPE_NAME (class_type))))
5718     WFL_STRIP_BRACKET (cl, cl);
5719
5720   /* 2- Resolve the bare type */
5721   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5722                                                decl, cl)))
5723     return NULL_TREE;
5724   resolved_type = TREE_TYPE (resolved_type_decl);
5725
5726   /* 3- If we have an array, reconstruct the array down to its nesting */
5727   if (array_dims)
5728     {
5729       for (; array_dims; array_dims--)
5730         resolved_type = build_java_array_type (resolved_type, -1);
5731       resolved_type_decl = TYPE_NAME (resolved_type);
5732     }
5733   TREE_TYPE (class_type) = resolved_type;
5734   return resolved_type_decl;
5735 }
5736
5737 /* Effectively perform the resolution of class CLASS_TYPE.  DECL or CL
5738    are used to report error messages; CL must either be NULL_TREE or a
5739    WFL wrapping a class.  Do not try to replace TYPE_NAME (class_type)
5740    by a variable, since it is changed by find_in_imports{_on_demand}
5741    and (but it doesn't really matter) qualify_and_find.  */
5742
5743 tree
5744 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5745 {
5746   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5747   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5748   tree decl_result;
5749   htab_t circularity_hash;
5750
5751   if (QUALIFIED_P (TYPE_NAME (class_type)))
5752     {
5753       /* If the type name is of the form `Q . Id', then Q is either a
5754          package name or a class name.  First we try to find Q as a
5755          class and then treat Id as a member type.  If we can't find Q
5756          as a class then we fall through.  */
5757       tree q, left, left_type, right;
5758       if (breakdown_qualified (&left, &right, TYPE_NAME (class_type)) == 0)
5759         {
5760           BUILD_PTR_FROM_NAME (left_type, left);
5761           q = do_resolve_class (enclosing, left_type, decl, cl);
5762           if (q)
5763             {
5764               enclosing = q;
5765               saved_enclosing_type = TREE_TYPE (q);
5766               BUILD_PTR_FROM_NAME (class_type, right);
5767             }
5768         }
5769     }
5770
5771   if (enclosing)
5772     {
5773       /* This hash table is used to register the classes we're going
5774          through when searching the current class as an inner class, in
5775          order to detect circular references. Remember to free it before
5776          returning the section 0- of this function. */
5777       circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5778                                       NULL);
5779
5780       /* 0- Search in the current class as an inner class.
5781          Maybe some code here should be added to load the class or
5782          something, at least if the class isn't an inner class and ended
5783          being loaded from class file. FIXME. */
5784       while (enclosing)
5785         {
5786           new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5787                                                 &super, class_type);
5788           if (new_class_decl)
5789             break;
5790
5791           /* If we haven't found anything because SUPER reached Object and
5792              ENCLOSING happens to be an innerclass, try the enclosing context. */
5793           if ((!super || super == object_type_node) &&
5794               enclosing && INNER_CLASS_DECL_P (enclosing))
5795             enclosing = DECL_CONTEXT (enclosing);
5796           else
5797             enclosing = NULL_TREE;
5798         }
5799
5800       htab_delete (circularity_hash);
5801
5802       if (new_class_decl)
5803         return new_class_decl;
5804     }
5805
5806   /* 1- Check for the type in single imports. This will change
5807      TYPE_NAME() if something relevant is found */
5808   find_in_imports (saved_enclosing_type, class_type);
5809
5810   /* 2- And check for the type in the current compilation unit */
5811   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5812     {
5813       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5814           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5815         load_class (TYPE_NAME (class_type), 0);
5816       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5817     }
5818
5819   /* 3- Search according to the current package definition */
5820   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5821     {
5822       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5823                                              TYPE_NAME (class_type))))
5824         return new_class_decl;
5825     }
5826
5827   /* 4- Check the import on demands. Don't allow bar.baz to be
5828      imported from foo.* */
5829   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5830     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5831       return NULL_TREE;
5832
5833   /* If found in find_in_imports_on_demand, the type has already been
5834      loaded. */
5835   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5836     return new_class_decl;
5837
5838   /* 5- Try with a name qualified with the package name we've seen so far */
5839   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5840     {
5841       tree package;
5842
5843       /* If there is a current package (ctxp->package), it's the first
5844          element of package_list and we can skip it. */
5845       for (package = (ctxp->package ?
5846                       TREE_CHAIN (package_list) : package_list);
5847            package; package = TREE_CHAIN (package))
5848         if ((new_class_decl = qualify_and_find (class_type,
5849                                                TREE_PURPOSE (package),
5850                                                TYPE_NAME (class_type))))
5851           return new_class_decl;
5852     }
5853
5854   /* 5- Check another compilation unit that bears the name of type */
5855   load_class (TYPE_NAME (class_type), 0);
5856
5857   if (!cl)
5858     cl = lookup_cl (decl);
5859
5860   /* If we don't have a value for CL, then we're being called recursively.
5861      We can't check package access just yet, but it will be taken care of
5862      by the caller. */
5863   if (cl)
5864     {
5865       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true, NULL_TREE))
5866         return NULL_TREE;
5867     }
5868
5869   /* 6- Last call for a resolution */
5870   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5871
5872   /* The final lookup might have registered a.b.c into a.b$c If we
5873      failed at the first lookup, progressively change the name if
5874      applicable and use the matching DECL instead. */
5875   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5876     {
5877       char *separator;
5878       tree name = TYPE_NAME (class_type);
5879       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
5880
5881       strcpy (namebuffer, IDENTIFIER_POINTER (name));
5882
5883       do {
5884
5885        /* Reach the last '.', and if applicable, replace it by a `$' and
5886           see if this exists as a type. */
5887        if ((separator = strrchr (namebuffer, '.')))
5888          {
5889            *separator = '$';
5890            name = get_identifier (namebuffer);
5891            decl_result = IDENTIFIER_CLASS_VALUE (name);
5892          }
5893       } while (!decl_result && separator);
5894     }
5895   return decl_result;
5896 }
5897
5898 static tree
5899 qualify_and_find (tree class_type, tree package, tree name)
5900 {
5901   tree new_qualified = merge_qualified_name (package, name);
5902   tree new_class_decl;
5903
5904   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5905     load_class (new_qualified, 0);
5906   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5907     {
5908       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5909           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5910         load_class (new_qualified, 0);
5911       TYPE_NAME (class_type) = new_qualified;
5912       return IDENTIFIER_CLASS_VALUE (new_qualified);
5913     }
5914   return NULL_TREE;
5915 }
5916
5917 /* Resolve NAME and lay it out (if not done and if not the current
5918    parsed class). Return a decl node. This function is meant to be
5919    called when type resolution is necessary during the walk pass.  */
5920
5921 static tree
5922 resolve_and_layout (tree something, tree cl)
5923 {
5924   tree decl, decl_type;
5925
5926   /* Don't do that on the current class */
5927   if (something == current_class)
5928     return TYPE_NAME (current_class);
5929
5930   /* Don't do anything for void and other primitive types */
5931   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5932     return NULL_TREE;
5933
5934   /* Pointer types can be reall pointer types or fake pointers. When
5935      finding a real pointer, recheck for primitive types */
5936   if (TREE_CODE (something) == POINTER_TYPE)
5937     {
5938       if (TREE_TYPE (something))
5939         {
5940           something = TREE_TYPE (something);
5941           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5942             return NULL_TREE;
5943         }
5944       else
5945         something = TYPE_NAME (something);
5946     }
5947
5948   /* Don't do anything for arrays of primitive types */
5949   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5950       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5951     return NULL_TREE;
5952
5953   /* Something might be a WFL */
5954   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5955     something = EXPR_WFL_NODE (something);
5956
5957   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5958      TYPE_DECL or a real TYPE */
5959   else if (TREE_CODE (something) != IDENTIFIER_NODE)
5960     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5961             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5962
5963   if (!(decl = resolve_no_layout (something, cl)))
5964     return NULL_TREE;
5965
5966   /* Resolve and layout if necessary */
5967   decl_type = TREE_TYPE (decl);
5968   layout_class_methods (decl_type);
5969   /* Check methods */
5970   if (CLASS_FROM_SOURCE_P (decl_type))
5971     java_check_methods (decl);
5972   /* Layout the type if necessary */
5973   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5974     safe_layout_class (decl_type);
5975
5976   return decl;
5977 }
5978
5979 /* Resolve a class, returns its decl but doesn't perform any
5980    layout. The current parsing context is saved and restored */
5981
5982 static tree
5983 resolve_no_layout (tree name, tree cl)
5984 {
5985   tree ptr, decl;
5986   BUILD_PTR_FROM_NAME (ptr, name);
5987   java_parser_context_save_global ();
5988   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5989   java_parser_context_restore_global ();
5990
5991   return decl;
5992 }
5993
5994 /* Called when reporting errors. Skip the '[]'s in a complex array
5995    type description that failed to be resolved. purify_type_name can't
5996    use an identifier tree.  */
5997
5998 static const char *
5999 purify_type_name (const char *name)
6000 {
6001   int len = strlen (name);
6002   int bracket_found;
6003
6004   STRING_STRIP_BRACKETS (name, len, bracket_found);
6005   if (bracket_found)
6006     {
6007       char *stripped_name = xmemdup (name, len, len+1);
6008       stripped_name [len] = '\0';
6009       return stripped_name;
6010     }
6011   return name;
6012 }
6013
6014 /* The type CURRENT refers to can't be found. We print error messages.  */
6015
6016 static void
6017 complete_class_report_errors (jdep *dep)
6018 {
6019   const char *name;
6020
6021   if (!JDEP_WFL (dep))
6022     return;
6023
6024   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6025   switch (JDEP_KIND (dep))
6026     {
6027     case JDEP_SUPER:
6028       parse_error_context
6029         (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
6030          purify_type_name (name),
6031          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6032       break;
6033     case JDEP_FIELD:
6034       parse_error_context
6035         (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
6036          purify_type_name (name),
6037          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6038       break;
6039     case JDEP_METHOD:           /* Covers arguments */
6040       parse_error_context
6041         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
6042          purify_type_name (name),
6043          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6044          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6045       break;
6046     case JDEP_METHOD_RETURN:    /* Covers return type */
6047       parse_error_context
6048         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
6049          purify_type_name (name),
6050          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6051       break;
6052     case JDEP_INTERFACE:
6053       parse_error_context
6054         (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
6055          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6056          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6057          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6058       break;
6059     case JDEP_VARIABLE:
6060       parse_error_context
6061         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
6062          purify_type_name (IDENTIFIER_POINTER
6063                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6064          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6065       break;
6066     case JDEP_EXCEPTION:        /* As specified by `throws' */
6067       parse_error_context
6068           (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6069          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6070       break;
6071     default:
6072       /* Fix for -Wall. Just break doing nothing. The error will be
6073          caught later */
6074       break;
6075     }
6076 }
6077
6078 /* Return a static string containing the DECL prototype string. If
6079    DECL is a constructor, use the class name instead of the form
6080    <init> */
6081
6082 static const char *
6083 get_printable_method_name (tree decl)
6084 {
6085   const char *to_return;
6086   tree name = NULL_TREE;
6087
6088   if (DECL_CONSTRUCTOR_P (decl))
6089     {
6090       name = DECL_NAME (decl);
6091       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6092     }
6093
6094   to_return = lang_printable_name (decl, 0);
6095   if (DECL_CONSTRUCTOR_P (decl))
6096     DECL_NAME (decl) = name;
6097
6098   return to_return;
6099 }
6100
6101 /* Track method being redefined inside the same class. As a side
6102    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6103    function it's a FWL, so we can track errors more accurately.)  */
6104
6105 static int
6106 check_method_redefinition (tree class, tree method)
6107 {
6108   tree redef, sig;
6109
6110   /* There's no need to verify <clinit> and finit$ and instinit$ */
6111   if (DECL_CLINIT_P (method)
6112       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6113     return 0;
6114
6115   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6116   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6117     {
6118       if (redef == method)
6119         break;
6120       if (DECL_NAME (redef) == DECL_NAME (method)
6121           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6122           && !DECL_ARTIFICIAL (method))
6123         {
6124           parse_error_context
6125             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6126              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6127              get_printable_method_name (redef));
6128           return 1;
6129         }
6130     }
6131   return 0;
6132 }
6133
6134 /* Return 1 if check went ok, 0 otherwise.  */
6135 static int
6136 check_abstract_method_definitions (int do_interface, tree class_decl,
6137                                    tree type)
6138 {
6139   tree class = TREE_TYPE (class_decl);
6140   tree method, end_type;
6141   int ok = 1;
6142
6143   end_type = (do_interface ? object_type_node : type);
6144   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6145     {
6146       tree other_super, other_method, method_sig, method_name;
6147       int found = 0;
6148       int end_type_reached = 0;
6149
6150       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6151         continue;
6152
6153       /* Now verify that somewhere in between TYPE and CLASS,
6154          abstract method METHOD gets a non abstract definition
6155          that is inherited by CLASS.  */
6156
6157       method_sig = build_java_signature (TREE_TYPE (method));
6158       method_name = DECL_NAME (method);
6159       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6160         method_name = EXPR_WFL_NODE (method_name);
6161
6162       other_super = class;
6163       do {
6164         if (other_super == end_type)
6165           end_type_reached = 1;
6166
6167         /* Method search */
6168         for (other_method = TYPE_METHODS (other_super); other_method;
6169             other_method = TREE_CHAIN (other_method))
6170           {
6171             tree s = build_java_signature (TREE_TYPE (other_method));
6172             tree other_name = DECL_NAME (other_method);
6173
6174             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6175               other_name = EXPR_WFL_NODE (other_name);
6176             if (!DECL_CLINIT_P (other_method)
6177                 && !DECL_CONSTRUCTOR_P (other_method)
6178                 && method_name == other_name
6179                 && method_sig == s
6180                 && !METHOD_ABSTRACT (other_method))
6181              {
6182                found = 1;
6183                break;
6184              }
6185           }
6186         other_super = CLASSTYPE_SUPER (other_super);
6187       } while (!end_type_reached);
6188
6189       /* Report that abstract METHOD didn't find an implementation
6190          that CLASS can use. */
6191       if (!found)
6192         {
6193           char *t = xstrdup (lang_printable_name
6194                             (TREE_TYPE (TREE_TYPE (method)), 0));
6195           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6196
6197           parse_error_context
6198             (lookup_cl (class_decl),
6199              "Class `%s' doesn't define the abstract method `%s %s' from %s `%s'. This method must be defined or %s `%s' must be declared abstract",
6200              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6201              t, lang_printable_name (method, 0),
6202              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6203               "interface" : "class"),
6204              IDENTIFIER_POINTER (ccn),
6205              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6206              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6207           ok = 0;
6208           free (t);
6209         }
6210     }
6211
6212   if (ok && do_interface)
6213     {
6214       /* Check for implemented interfaces. */
6215       int i;
6216       tree vector = TYPE_BINFO_BASETYPES (type);
6217       for (i = 1; ok && vector && i < TREE_VEC_LENGTH (vector); i++)
6218         {
6219           tree super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6220           ok = check_abstract_method_definitions (1, class_decl, super);
6221         }
6222     }
6223
6224   return ok;
6225 }
6226
6227 /* Check that CLASS_DECL somehow implements all inherited abstract
6228    methods.  */
6229
6230 static void
6231 java_check_abstract_method_definitions (tree class_decl)
6232 {
6233   tree class = TREE_TYPE (class_decl);
6234   tree super, vector;
6235   int i;
6236
6237   if (CLASS_ABSTRACT (class_decl))
6238     return;
6239
6240   /* Check for inherited types */
6241   super = class;
6242   do {
6243     super = CLASSTYPE_SUPER (super);
6244     check_abstract_method_definitions (0, class_decl, super);
6245   } while (super != object_type_node);
6246
6247   /* Check for implemented interfaces. */
6248   vector = TYPE_BINFO_BASETYPES (class);
6249   for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
6250     {
6251       super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6252       check_abstract_method_definitions (1, class_decl, super);
6253     }
6254 }
6255
6256 /* Check all the types method DECL uses and return 1 if all of them
6257    are now complete, 0 otherwise. This is used to check whether its
6258    safe to build a method signature or not.  */
6259
6260 static int
6261 check_method_types_complete (tree decl)
6262 {
6263   tree type = TREE_TYPE (decl);
6264   tree args;
6265
6266   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6267     return 0;
6268
6269   args = TYPE_ARG_TYPES (type);
6270   if (TREE_CODE (type) == METHOD_TYPE)
6271     args = TREE_CHAIN (args);
6272   for (; args != end_params_node; args = TREE_CHAIN (args))
6273     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6274       return 0;
6275
6276   return 1;
6277 }
6278
6279 /* Visible interface to check methods contained in CLASS_DECL */
6280
6281 void
6282 java_check_methods (tree class_decl)
6283 {
6284   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6285     return;
6286
6287   if (CLASS_INTERFACE (class_decl))
6288     java_check_abstract_methods (class_decl);
6289   else
6290     java_check_regular_methods (class_decl);
6291
6292   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6293 }
6294
6295 /* Like not_accessible_p, but doesn't refer to the current class at
6296    all.  */
6297 static bool
6298 hack_is_accessible_p (tree member, tree from_where)
6299 {
6300   int flags = get_access_flags_from_decl (member);
6301
6302   if (from_where == DECL_CONTEXT (member)
6303       || (flags & ACC_PUBLIC))
6304     return true;
6305
6306   if ((flags & ACC_PROTECTED))
6307     {
6308       if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6309         return true;
6310     }
6311
6312   if ((flags & ACC_PRIVATE))
6313     return false;
6314
6315   /* Package private, or protected.  */
6316   return in_same_package (TYPE_NAME (from_where),
6317                           TYPE_NAME (DECL_CONTEXT (member)));
6318 }
6319
6320 /* Check all the methods of CLASS_DECL. Methods are first completed
6321    then checked according to regular method existence rules.  If no
6322    constructor for CLASS_DECL were encountered, then build its
6323    declaration.  */
6324 static void
6325 java_check_regular_methods (tree class_decl)
6326 {
6327   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6328   tree method;
6329   tree class = TREE_TYPE (class_decl);
6330   tree found = NULL_TREE;
6331   tree mthrows;
6332
6333   /* It is not necessary to check methods defined in java.lang.Object */
6334   if (class == object_type_node)
6335     return;
6336
6337   if (!TYPE_NVIRTUALS (class))
6338     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6339
6340   /* Should take interfaces into account. FIXME */
6341   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6342     {
6343       tree sig;
6344       tree method_wfl = DECL_FUNCTION_WFL (method);
6345       int aflags;
6346
6347       /* Check for redefinitions */
6348       if (check_method_redefinition (class, method))
6349         continue;
6350
6351       /* We verify things thrown by the method.  They must inherit from
6352          java.lang.Throwable.  */
6353       for (mthrows = DECL_FUNCTION_THROWS (method);
6354            mthrows; mthrows = TREE_CHAIN (mthrows))
6355         {
6356           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6357             parse_error_context
6358               (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6359                IDENTIFIER_POINTER
6360                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6361         }
6362
6363       /* If we see one constructor a mark so we don't generate the
6364          default one.  Also skip other verifications: constructors
6365          can't be inherited hence hidden or overridden.  */
6366       if (DECL_CONSTRUCTOR_P (method))
6367         {
6368           saw_constructor = 1;
6369           continue;
6370         }
6371
6372       sig = build_java_argument_signature (TREE_TYPE (method));
6373       found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6374                                               SEARCH_SUPER | SEARCH_INTERFACE);
6375
6376       /* Inner class can't declare static methods */
6377       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6378         {
6379           char *t = xstrdup (lang_printable_name (class, 0));
6380           parse_error_context
6381             (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6382              lang_printable_name (method, 0), t);
6383           free (t);
6384         }
6385
6386       /* Nothing overrides or it's a private method. */
6387       if (!found)
6388         continue;
6389       if (METHOD_PRIVATE (found))
6390         {
6391           found = NULL_TREE;
6392           continue;
6393         }
6394
6395       /* If `found' is declared in an interface, make sure the
6396          modifier matches. */
6397       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6398           && clinit_identifier_node != DECL_NAME (found)
6399           && !METHOD_PUBLIC (method))
6400         {
6401           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6402           parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6403                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6404                                lang_printable_name (method, 0),
6405                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6406         }
6407
6408       /* Can't override a method with the same name and different return
6409          types. */
6410       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6411         {
6412           char *t = xstrdup
6413             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6414           parse_error_context
6415             (method_wfl,
6416              "Method `%s' was defined with return type `%s' in class `%s'",
6417              lang_printable_name (found, 0), t,
6418              IDENTIFIER_POINTER
6419                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6420           free (t);
6421         }
6422
6423       aflags = get_access_flags_from_decl (found);
6424
6425       /* Can't override final. Can't override static. */
6426       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6427         {
6428           /* Static *can* override static */
6429           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6430             continue;
6431           parse_error_context
6432             (method_wfl,
6433              "%s methods can't be overridden. Method `%s' is %s in class `%s'",
6434              (METHOD_FINAL (found) ? "Final" : "Static"),
6435              lang_printable_name (found, 0),
6436              (METHOD_FINAL (found) ? "final" : "static"),
6437              IDENTIFIER_POINTER
6438                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6439           continue;
6440         }
6441
6442       /* Static method can't override instance method. */
6443       if (METHOD_STATIC (method))
6444         {
6445           parse_error_context
6446             (method_wfl,
6447              "Instance methods can't be overridden by a static method. Method `%s' is an instance method in class `%s'",
6448              lang_printable_name (found, 0),
6449              IDENTIFIER_POINTER
6450                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6451           continue;
6452         }
6453
6454       /* - Overriding/hiding public must be public
6455          - Overriding/hiding protected must be protected or public
6456          - If the overridden or hidden method has default (package)
6457            access, then the overriding or hiding method must not be
6458            private; otherwise, a compile-time error occurs.  If
6459            `found' belongs to an interface, things have been already
6460            taken care of.  */
6461       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6462           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6463               || (METHOD_PROTECTED (found)
6464                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6465               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6466                   && METHOD_PRIVATE (method))))
6467         {
6468           parse_error_context
6469             (method_wfl,
6470              "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6471              (METHOD_PUBLIC (method) ? "public" :
6472               (METHOD_PRIVATE (method) ? "private" : "protected")),
6473              IDENTIFIER_POINTER (DECL_NAME
6474                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6475           continue;
6476         }
6477
6478       /* Check this method against all the other implementations it
6479          overrides.  Here we only check the class hierarchy; the rest
6480          of the checking is done later.  If this method is just a
6481          Miranda method, we can skip the check.  */
6482       if (! METHOD_INVISIBLE (method))
6483         check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6484     }
6485
6486   /* The above throws clause check only looked at superclasses.  Now
6487      we must also make sure that all methods declared in interfaces
6488      have compatible throws clauses.  FIXME: there are more efficient
6489      ways to organize this checking; we should implement one.  */
6490   check_interface_throws_clauses (class, class);
6491
6492   if (!TYPE_NVIRTUALS (class))
6493     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6494
6495   /* Search for inherited abstract method not yet implemented in this
6496      class.  */
6497   java_check_abstract_method_definitions (class_decl);
6498
6499   if (!saw_constructor)
6500     abort ();
6501 }
6502
6503 /* Check to make sure that all the methods in all the interfaces
6504    implemented by CLASS_DECL are compatible with the concrete
6505    implementations available in CHECK_CLASS_DECL.  */
6506 static void
6507 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6508 {
6509   for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6510     {
6511       tree bases;
6512       int iface_len;
6513       int i;
6514
6515       if (! CLASS_LOADED_P (class_decl))
6516         {
6517           if (CLASS_FROM_SOURCE_P (class_decl))
6518             safe_layout_class (class_decl);
6519           else
6520             load_class (class_decl, 1);
6521         }
6522
6523       bases = TYPE_BINFO_BASETYPES (class_decl);
6524       iface_len = TREE_VEC_LENGTH (bases) - 1;
6525       for (i = iface_len; i > 0; --i)
6526         {
6527           tree interface = BINFO_TYPE (TREE_VEC_ELT (bases, i));
6528           tree iface_method;
6529
6530           for (iface_method = TYPE_METHODS (interface);
6531                iface_method != NULL_TREE;
6532                iface_method = TREE_CHAIN (iface_method))
6533             {
6534               tree sig, method;
6535
6536               /* First look for a concrete method implemented or
6537                  inherited by this class.  No need to search
6538                  interfaces here, since we're already looking through
6539                  all of them.  */
6540               sig = build_java_argument_signature (TREE_TYPE (iface_method));
6541               method
6542                 = lookup_argument_method_generic (check_class_decl,
6543                                                   DECL_NAME (iface_method),
6544                                                   sig, SEARCH_VISIBLE);
6545               /* If we don't find an implementation, that is ok.  Any
6546                  potential errors from that are diagnosed elsewhere.
6547                  Also, multiple inheritance with conflicting throws
6548                  clauses is fine in the absence of a concrete
6549                  implementation.  */
6550               if (method != NULL_TREE && !METHOD_ABSTRACT (method)
6551                   && !METHOD_INVISIBLE (iface_method))
6552                 {
6553                   tree method_wfl = DECL_FUNCTION_WFL (method);
6554                   check_throws_clauses (method, method_wfl, iface_method);
6555                 }
6556             }
6557
6558           /* Now check superinterfaces.  */
6559           check_interface_throws_clauses (check_class_decl, interface);
6560         }
6561     }
6562 }
6563
6564 /* Check throws clauses of a method against the clauses of all the
6565    methods it overrides.  We do this by searching up the class
6566    hierarchy, examining all matching accessible methods.  */
6567 static void
6568 check_concrete_throws_clauses (tree class, tree self_method,
6569                                tree name, tree signature)
6570 {
6571   tree method = lookup_argument_method_generic (class, name, signature,
6572                                                 SEARCH_SUPER | SEARCH_VISIBLE);
6573   while (method != NULL_TREE)
6574     {
6575       if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6576         check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6577                               method);
6578
6579       method = lookup_argument_method_generic (DECL_CONTEXT (method),
6580                                                name, signature,
6581                                                SEARCH_SUPER | SEARCH_VISIBLE);
6582     }
6583 }
6584
6585 /* Generate an error if the `throws' clause of METHOD (if any) is
6586    incompatible with the `throws' clause of FOUND (if any).  */
6587 static void
6588 check_throws_clauses (tree method, tree method_wfl, tree found)
6589 {
6590   tree mthrows;
6591
6592   /* Can't check these things with class loaded from bytecode. FIXME */
6593   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6594     return;
6595
6596   for (mthrows = DECL_FUNCTION_THROWS (method);
6597        mthrows; mthrows = TREE_CHAIN (mthrows))
6598     {
6599       tree fthrows;
6600
6601       /* We don't verify unchecked expressions */
6602       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6603         continue;
6604       /* Checked expression must be compatible */
6605       for (fthrows = DECL_FUNCTION_THROWS (found);
6606            fthrows; fthrows = TREE_CHAIN (fthrows))
6607         {
6608           if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6609             break;
6610         }
6611       if (!fthrows)
6612         {
6613           parse_error_context
6614             (method_wfl, "Invalid checked exception class `%s' in `throws' clause.  The exception must be a subclass of an exception thrown by `%s' from class `%s'",
6615              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6616              lang_printable_name (found, 0),
6617              IDENTIFIER_POINTER
6618              (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6619         }
6620     }
6621 }
6622
6623 /* Check abstract method of interface INTERFACE */
6624 static void
6625 java_check_abstract_methods (tree interface_decl)
6626 {
6627   int i, n;
6628   tree method, basetype_vec, found;
6629   tree interface = TREE_TYPE (interface_decl);
6630
6631   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6632     {
6633       /* 2- Check for double definition inside the defining interface */
6634       if (check_method_redefinition (interface, method))
6635         continue;
6636
6637       /* 3- Overriding is OK as far as we preserve the return type.  */
6638       found = lookup_java_interface_method2 (interface, method);
6639       if (found)
6640         {
6641           char *t;
6642           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6643           parse_error_context
6644             (DECL_FUNCTION_WFL (found),
6645              "Method `%s' was defined with return type `%s' in class `%s'",
6646              lang_printable_name (found, 0), t,
6647              IDENTIFIER_POINTER
6648                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6649           free (t);
6650           continue;
6651         }
6652     }
6653
6654   /* 4- Inherited methods can't differ by their returned types */
6655   if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6656     return;
6657   n = TREE_VEC_LENGTH (basetype_vec);
6658   for (i = 0; i < n; i++)
6659     {
6660       tree sub_interface_method, sub_interface;
6661       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6662       if (!vec_elt)
6663         continue;
6664       sub_interface = BINFO_TYPE (vec_elt);
6665       for (sub_interface_method = TYPE_METHODS (sub_interface);
6666            sub_interface_method;
6667            sub_interface_method = TREE_CHAIN (sub_interface_method))
6668         {
6669           found = lookup_java_interface_method2 (interface,
6670                                                  sub_interface_method);
6671           if (found && (found != sub_interface_method))
6672             {
6673               parse_error_context
6674                 (lookup_cl (sub_interface_method),
6675                  "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6676                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6677                  lang_printable_name (found, 0),
6678                  IDENTIFIER_POINTER
6679                    (DECL_NAME (TYPE_NAME
6680                                (DECL_CONTEXT (sub_interface_method)))),
6681                  IDENTIFIER_POINTER
6682                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6683             }
6684         }
6685     }
6686 }
6687
6688 /* Lookup methods in interfaces using their name and partial
6689    signature. Return a matching method only if their types differ.  */
6690
6691 static tree
6692 lookup_java_interface_method2 (tree class, tree method_decl)
6693 {
6694   int i, n;
6695   tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6696
6697   if (!basetype_vec)
6698     return NULL_TREE;
6699
6700   n = TREE_VEC_LENGTH (basetype_vec);
6701   for (i = 0; i < n; i++)
6702     {
6703       tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6704       if ((BINFO_TYPE (vec_elt) != object_type_node)
6705           && (to_return =
6706               lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6707         return to_return;
6708     }
6709   for (i = 0; i < n; i++)
6710     {
6711       to_return = lookup_java_interface_method2
6712         (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6713       if (to_return)
6714         return to_return;
6715     }
6716
6717   return NULL_TREE;
6718 }
6719
6720 /* Lookup method using their name and partial signature. Return a
6721    matching method only if their types differ.  */
6722
6723 static tree
6724 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6725 {
6726   tree method, method_signature, method_name, method_type, name;
6727
6728   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6729   name = DECL_NAME (method_decl);
6730   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6731                  EXPR_WFL_NODE (name) : name);
6732   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6733
6734   while (clas != NULL_TREE)
6735     {
6736       for (method = TYPE_METHODS (clas);
6737            method != NULL_TREE;  method = TREE_CHAIN (method))
6738         {
6739           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6740           tree name = DECL_NAME (method);
6741           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6742                EXPR_WFL_NODE (name) : name) == method_name
6743               && method_sig == method_signature
6744               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6745             return method;
6746         }
6747       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6748     }
6749   return NULL_TREE;
6750 }
6751
6752 /* Return the line that matches DECL line number, and try its best to
6753    position the column number. Used during error reports.  */
6754
6755 static GTY(()) tree cl_v;
6756 static tree
6757 lookup_cl (tree decl)
6758 {
6759   char *line, *found;
6760
6761   if (!decl)
6762     return NULL_TREE;
6763
6764   if (cl_v == NULL_TREE)
6765     {
6766       cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6767     }
6768
6769   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6770   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6771
6772   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6773                             EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6774
6775   found = strstr ((const char *)line,
6776                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6777   if (found)
6778     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6779
6780   return cl_v;
6781 }
6782
6783 /* Look for a simple name in the single-type import list */
6784
6785 static tree
6786 find_name_in_single_imports (tree name)
6787 {
6788   tree node;
6789
6790   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6791     if (TREE_VALUE (node) == name)
6792       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6793
6794   return NULL_TREE;
6795 }
6796
6797 /* Process all single-type import. */
6798
6799 static int
6800 process_imports (void)
6801 {
6802   tree import;
6803   int error_found;
6804
6805   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6806     {
6807       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6808       char *original_name;
6809
6810       original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6811                                IDENTIFIER_LENGTH (to_be_found),
6812                                IDENTIFIER_LENGTH (to_be_found) + 1);
6813
6814       /* Don't load twice something already defined. */
6815       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6816         continue;
6817
6818       while (1)
6819         {
6820           tree left;
6821
6822           QUALIFIED_P (to_be_found) = 1;
6823           load_class (to_be_found, 0);
6824           error_found =
6825             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true, NULL_TREE);
6826
6827           /* We found it, we can bail out */
6828           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6829             {
6830               check_deprecation (TREE_PURPOSE (import),
6831                                  IDENTIFIER_CLASS_VALUE (to_be_found));
6832               break;
6833             }
6834
6835           /* We haven't found it. Maybe we're trying to access an
6836              inner class.  The only way for us to know is to try again
6837              after having dropped a qualifier. If we can't break it further,
6838              we have an error. */
6839           if (breakdown_qualified (&left, NULL, to_be_found))
6840             break;
6841
6842           to_be_found = left;
6843         }
6844       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6845         {
6846           parse_error_context (TREE_PURPOSE (import),
6847                                "Class or interface `%s' not found in import",
6848                                original_name);
6849           error_found = 1;
6850         }
6851
6852       free (original_name);
6853       if (error_found)
6854         return 1;
6855     }
6856   return 0;
6857 }
6858
6859 /* Possibly find and mark a class imported by a single-type import
6860    statement.  */
6861
6862 static void
6863 find_in_imports (tree enclosing_type, tree class_type)
6864 {
6865   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6866                  ctxp->import_list);
6867   while (import)
6868     {
6869       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6870         {
6871           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6872           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6873           return;
6874         }
6875       import = TREE_CHAIN (import);
6876     }
6877 }
6878
6879 static int
6880 note_possible_classname (const char *name, int len)
6881 {
6882   tree node;
6883   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6884     len = len - 5;
6885   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6886     len = len - 6;
6887   else
6888     return 0;
6889   node = ident_subst (name, len, "", '/', '.', "");
6890   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6891   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6892   return 1;
6893 }
6894
6895 /* Read a import directory, gathering potential match for further type
6896    references. Indifferently reads a filesystem or a ZIP archive
6897    directory.  */
6898
6899 static void
6900 read_import_dir (tree wfl)
6901 {
6902   tree package_id = EXPR_WFL_NODE (wfl);
6903   const char *package_name = IDENTIFIER_POINTER (package_id);
6904   int package_length = IDENTIFIER_LENGTH (package_id);
6905   DIR *dirp = NULL;
6906   JCF *saved_jcf = current_jcf;
6907
6908   int found = 0;
6909   int k;
6910   void *entry;
6911   struct buffer filename[1];
6912
6913   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6914     return;
6915   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6916
6917   BUFFER_INIT (filename);
6918   buffer_grow (filename, package_length + 100);
6919
6920   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6921     {
6922       const char *entry_name = jcf_path_name (entry);
6923       int entry_length = strlen (entry_name);
6924       if (jcf_path_is_zipfile (entry))
6925         {
6926           ZipFile *zipf;
6927           buffer_grow (filename, entry_length);
6928           memcpy (filename->data, entry_name, entry_length - 1);
6929           filename->data[entry_length-1] = '\0';
6930           zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6931           if (zipf == NULL)
6932             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6933           else
6934             {
6935               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6936               BUFFER_RESET (filename);
6937               for (k = 0; k < package_length; k++)
6938                 {
6939                   char ch = package_name[k];
6940                   *filename->ptr++ = ch == '.' ? '/' : ch;
6941                 }
6942               *filename->ptr++ = '/';
6943
6944               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
6945                 {
6946                   const char *current_entry = ZIPDIR_FILENAME (zipd);
6947                   int current_entry_len = zipd->filename_length;
6948
6949                   if (current_entry_len >= BUFFER_LENGTH (filename)
6950                       && strncmp (filename->data, current_entry,
6951                                   BUFFER_LENGTH (filename)) != 0)
6952                     continue;
6953                   found |= note_possible_classname (current_entry,
6954                                                     current_entry_len);
6955                 }
6956             }
6957         }
6958       else
6959         {
6960           BUFFER_RESET (filename);
6961           buffer_grow (filename, entry_length + package_length + 4);
6962           strcpy (filename->data, entry_name);
6963           filename->ptr = filename->data + entry_length;
6964           for (k = 0; k < package_length; k++)
6965             {
6966               char ch = package_name[k];
6967               *filename->ptr++ = ch == '.' ? '/' : ch;
6968             }
6969           *filename->ptr = '\0';
6970
6971           dirp = opendir (filename->data);
6972           if (dirp == NULL)
6973             continue;
6974           *filename->ptr++ = '/';
6975           for (;;)
6976             {
6977               int len;
6978               const char *d_name;
6979               struct dirent *direntp = readdir (dirp);
6980               if (!direntp)
6981                 break;
6982               d_name = direntp->d_name;
6983               len = strlen (direntp->d_name);
6984               buffer_grow (filename, len+1);
6985               strcpy (filename->ptr, d_name);
6986               found |= note_possible_classname (filename->data + entry_length,
6987                                                 package_length+len+1);
6988             }
6989           if (dirp)
6990             closedir (dirp);
6991         }
6992     }
6993
6994   free (filename->data);
6995
6996   /* Here we should have a unified way of retrieving an entry, to be
6997      indexed. */
6998   if (!found)
6999     {
7000       static int first = 1;
7001       if (first)
7002         {
7003           error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
7004           java_error_count++;
7005           first = 0;
7006         }
7007       else
7008         parse_error_context (wfl, "Package `%s' not found in import",
7009                              package_name);
7010       current_jcf = saved_jcf;
7011       return;
7012     }
7013   current_jcf = saved_jcf;
7014 }
7015
7016 /* Possibly find a type in the import on demands specified
7017    types. Returns 1 if an error occurred, 0 otherwise. Run through the
7018    entire list, to detected potential double definitions.  */
7019
7020 static int
7021 find_in_imports_on_demand (tree enclosing_type, tree class_type)
7022 {
7023   tree class_type_name = TYPE_NAME (class_type);
7024   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
7025                   ctxp->import_demand_list);
7026   tree cl = NULL_TREE;
7027   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
7028   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
7029   tree node;
7030
7031   for (; import; import = TREE_CHAIN (import))
7032     {
7033       int saved_lineno = input_line;
7034       int access_check;
7035       const char *id_name;
7036       tree decl, type_name_copy;
7037
7038       obstack_grow (&temporary_obstack,
7039                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
7040                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
7041       obstack_1grow (&temporary_obstack, '.');
7042       obstack_grow0 (&temporary_obstack,
7043                      IDENTIFIER_POINTER (class_type_name),
7044                      IDENTIFIER_LENGTH (class_type_name));
7045       id_name = obstack_finish (&temporary_obstack);
7046
7047       if (! (node = maybe_get_identifier (id_name)))
7048         continue;
7049
7050       /* Setup input_line so that it refers to the line of the import (in
7051          case we parse a class file and encounter errors */
7052       input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
7053
7054       type_name_copy = TYPE_NAME (class_type);
7055       TYPE_NAME (class_type) = node;
7056       QUALIFIED_P (node) = 1;
7057       decl = IDENTIFIER_CLASS_VALUE (node);
7058       access_check = -1;
7059       /* If there is no DECL set for the class or if the class isn't
7060          loaded and not seen in source yet, then load */
7061       if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
7062                     && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
7063         {
7064           load_class (node, 0);
7065           decl = IDENTIFIER_CLASS_VALUE (node);
7066         }
7067       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7068         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7069                                                false, NULL_TREE);
7070       else
7071         /* 6.6.1: Inner classes are subject to member access rules. */
7072         access_check = 0;
7073
7074       input_line = saved_lineno;
7075
7076       /* If the loaded class is not accessible or couldn't be loaded,
7077          we restore the original TYPE_NAME and process the next
7078          import. */
7079       if (access_check || !decl)
7080         {
7081           TYPE_NAME (class_type) = type_name_copy;
7082           continue;
7083         }
7084
7085       /* If the loaded class is accessible, we keep a tab on it to
7086          detect and report multiple inclusions. */
7087       if (IS_A_CLASSFILE_NAME (node))
7088         {
7089           if (seen_once < 0)
7090             {
7091               cl = TREE_PURPOSE (import);
7092               seen_once = 1;
7093             }
7094           else if (seen_once >= 0)
7095             {
7096               tree location = (cl ? cl : TREE_PURPOSE (import));
7097               tree package = (cl ? EXPR_WFL_NODE (cl) :
7098                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
7099               seen_once++;
7100               parse_error_context
7101                 (location,
7102                  "Type `%s' also potentially defined in package `%s'",
7103                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7104                  IDENTIFIER_POINTER (package));
7105             }
7106         }
7107       to_return = access_check;
7108     }
7109
7110   if (seen_once == 1)
7111     return to_return;
7112   else
7113     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7114 }
7115
7116 /* Add package NAME to the list of packages encountered so far. To
7117    speed up class lookup in do_resolve_class, we make sure a
7118    particular package is added only once.  */
7119
7120 static void
7121 register_package (tree name)
7122 {
7123   static htab_t pht;
7124   void **e;
7125
7126   if (pht == NULL)
7127     pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
7128
7129   e = htab_find_slot (pht, name, INSERT);
7130   if (*e == NULL)
7131     {
7132       package_list = chainon (package_list, build_tree_list (name, NULL));
7133       *e = name;
7134     }
7135 }
7136
7137 static tree
7138 resolve_package (tree pkg, tree *next, tree *type_name)
7139 {
7140   tree current;
7141   tree decl = NULL_TREE;
7142   *type_name = NULL_TREE;
7143
7144   /* The trick is to determine when the package name stops and were
7145      the name of something contained in the package starts. Then we
7146      return a fully qualified name of what we want to get. */
7147
7148   *next = EXPR_WFL_QUALIFICATION (pkg);
7149
7150   /* Try to progressively construct a type name */
7151   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7152     for (current = EXPR_WFL_QUALIFICATION (pkg);
7153          current; current = TREE_CHAIN (current))
7154       {
7155         /* If we don't have what we're expecting, exit now. TYPE_NAME
7156            will be null and the error caught later. */
7157         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7158           break;
7159         *type_name =
7160           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7161         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7162           {
7163             /* resolve_package should be used in a loop, hence we
7164                point at this one to naturally process the next one at
7165                the next iteration. */
7166             *next = current;
7167             break;
7168           }
7169       }
7170   return decl;
7171 }
7172
7173
7174 /* Check accessibility of inner classes according to member access rules.
7175    DECL is the inner class, ENCLOSING_DECL is the class from which the
7176    access is being attempted. */
7177
7178 static void
7179 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7180 {
7181   const char *access;
7182   tree enclosing_decl_type;
7183
7184   /* We don't issue an error message when CL is null. CL can be null
7185      as a result of processing a JDEP crafted by source_start_java_method
7186      for the purpose of patching its parm decl. But the error would
7187      have been already trapped when fixing the method's signature.
7188      DECL can also be NULL in case of earlier errors. */
7189   if (!decl || !cl)
7190     return;
7191
7192   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7193
7194   if (CLASS_PRIVATE (decl))
7195     {
7196       /* Access is permitted only within the body of the top-level
7197          class in which DECL is declared. */
7198       tree top_level = decl;
7199       while (DECL_CONTEXT (top_level))
7200         top_level = DECL_CONTEXT (top_level);
7201       while (DECL_CONTEXT (enclosing_decl))
7202         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7203       if (top_level == enclosing_decl)
7204         return;
7205       access = "private";
7206     }
7207   else if (CLASS_PROTECTED (decl))
7208     {
7209       tree decl_context;
7210       /* Access is permitted from within the same package... */
7211       if (in_same_package (decl, enclosing_decl))
7212         return;
7213
7214       /* ... or from within the body of a subtype of the context in which
7215          DECL is declared. */
7216       decl_context = DECL_CONTEXT (decl);
7217       while (enclosing_decl)
7218         {
7219           if (CLASS_INTERFACE (decl))
7220             {
7221               if (interface_of_p (TREE_TYPE (decl_context),
7222                                   enclosing_decl_type))
7223                 return;
7224             }
7225           else
7226             {
7227               /* Eww. The order of the arguments is different!! */
7228               if (inherits_from_p (enclosing_decl_type,
7229                                    TREE_TYPE (decl_context)))
7230                 return;
7231             }
7232           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7233         }
7234       access = "protected";
7235     }
7236   else if (! CLASS_PUBLIC (decl))
7237     {
7238       /* Access is permitted only from within the same package as DECL. */
7239       if (in_same_package (decl, enclosing_decl))
7240         return;
7241       access = "non-public";
7242     }
7243   else
7244     /* Class is public. */
7245     return;
7246
7247   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7248                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7249                        lang_printable_name (decl, 0), access);
7250 }
7251
7252 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7253    foreign package, it must be PUBLIC. Return 0 if no access
7254    violations were found, 1 otherwise. If VERBOSE is true and an error
7255    was found, it is reported and accounted for.  If CL is NULL then
7256    look it up with THIS_DECL.  */
7257
7258 static int
7259 check_pkg_class_access (tree class_name, tree cl, bool verbose, tree this_decl)
7260 {
7261   tree type;
7262
7263   if (!IDENTIFIER_CLASS_VALUE (class_name))
7264     return 0;
7265
7266   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7267     return 0;
7268
7269   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7270     {
7271       /* Access to a private class within the same package is
7272          allowed. */
7273       tree l, r;
7274       breakdown_qualified (&l, &r, class_name);
7275       if (!QUALIFIED_P (class_name) && !ctxp->package)
7276         /* Both in the empty package. */
7277         return 0;
7278       if (l == ctxp->package)
7279         /* Both in the same package. */
7280         return 0;
7281
7282       if (verbose)
7283         parse_error_context
7284           (cl == NULL ? lookup_cl (this_decl): cl,
7285            "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7286            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7287            IDENTIFIER_POINTER (class_name));
7288       return 1;
7289     }
7290   return 0;
7291 }
7292
7293 /* Local variable declaration. */
7294
7295 static void
7296 declare_local_variables (int modifier, tree type, tree vlist)
7297 {
7298   tree decl, current, saved_type;
7299   tree type_wfl = NULL_TREE;
7300   int must_chain = 0;
7301   int final_p = 0;
7302
7303   /* Push a new block if statements were seen between the last time we
7304      pushed a block and now. Keep a count of blocks to close */
7305   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7306     {
7307       tree b = enter_block ();
7308       BLOCK_IS_IMPLICIT (b) = 1;
7309     }
7310
7311   if (modifier)
7312     {
7313       size_t i;
7314       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7315         if (1 << i & modifier)
7316           break;
7317       if (modifier == ACC_FINAL)
7318         final_p = 1;
7319       else
7320         {
7321           parse_error_context
7322             (ctxp->modifier_ctx [i],
7323              "Only `final' is allowed as a local variables modifier");
7324           return;
7325         }
7326     }
7327
7328   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7329      hold the TYPE value if a new incomplete has to be created (as
7330      opposed to being found already existing and reused). */
7331   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7332
7333   /* If TYPE is fully resolved and we don't have a reference, make one */
7334   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7335
7336   /* Go through all the declared variables */
7337   for (current = vlist, saved_type = type; current;
7338        current = TREE_CHAIN (current), type = saved_type)
7339     {
7340       tree other, real_type;
7341       tree wfl  = TREE_PURPOSE (current);
7342       tree name = EXPR_WFL_NODE (wfl);
7343       tree init = TREE_VALUE (current);
7344
7345       /* Process NAME, as it may specify extra dimension(s) for it */
7346       type = build_array_from_name (type, type_wfl, name, &name);
7347
7348       /* Variable redefinition check */
7349       if ((other = lookup_name_in_blocks (name)))
7350         {
7351           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7352                                        DECL_SOURCE_LINE (other));
7353           continue;
7354         }
7355
7356       /* Type adjustment. We may have just readjusted TYPE because
7357          the variable specified more dimensions. Make sure we have
7358          a reference if we can and don't have one already. */
7359       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7360
7361       real_type = GET_REAL_TYPE (type);
7362       /* Never layout this decl. This will be done when its scope
7363          will be entered */
7364       decl = build_decl (VAR_DECL, name, real_type);
7365       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7366       DECL_FINAL (decl) = final_p;
7367       BLOCK_CHAIN_DECL (decl);
7368
7369       /* If doing xreferencing, replace the line number with the WFL
7370          compound value */
7371       if (flag_emit_xref)
7372         DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7373
7374       /* Don't try to use an INIT statement when an error was found */
7375       if (init && java_error_count)
7376         init = NULL_TREE;
7377
7378       /* Remember it if this is an initialized-upon-declaration final
7379          variable.  */
7380       if (init && final_p)
7381         {
7382           DECL_LOCAL_FINAL_IUD (decl) = 1;
7383         }
7384
7385       /* Add the initialization function to the current function's code */
7386       if (init)
7387         {
7388           /* Name might have been readjusted */
7389           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7390           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7391           java_method_add_stmt (current_function_decl,
7392                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7393                                                       init));
7394         }
7395
7396       /* Setup dependency the type of the decl */
7397       if (must_chain)
7398         {
7399           jdep *dep;
7400           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7401           dep = CLASSD_LAST (ctxp->classd_list);
7402           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7403         }
7404     }
7405   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7406 }
7407
7408 /* Called during parsing. Build decls from argument list.  */
7409
7410 static void
7411 source_start_java_method (tree fndecl)
7412 {
7413   tree tem;
7414   tree parm_decl;
7415   int i;
7416
7417   if (!fndecl)
7418     return;
7419
7420   current_function_decl = fndecl;
7421
7422   /* New scope for the function */
7423   enter_block ();
7424   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7425        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7426     {
7427       tree type = TREE_VALUE (tem);
7428       tree name = TREE_PURPOSE (tem);
7429
7430       /* If type is incomplete. Create an incomplete decl and ask for
7431          the decl to be patched later */
7432       if (INCOMPLETE_TYPE_P (type))
7433         {
7434           jdep *jdep;
7435           tree real_type = GET_REAL_TYPE (type);
7436           parm_decl = build_decl (PARM_DECL, name, real_type);
7437           type = obtain_incomplete_type (type);
7438           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7439           jdep = CLASSD_LAST (ctxp->classd_list);
7440           JDEP_MISC (jdep) = name;
7441           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7442         }
7443       else
7444         parm_decl = build_decl (PARM_DECL, name, type);
7445
7446       /* Remember if a local variable was declared final (via its
7447          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7448       if (ARG_FINAL_P (tem))
7449         {
7450           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7451           DECL_FINAL (parm_decl) = 1;
7452         }
7453
7454       BLOCK_CHAIN_DECL (parm_decl);
7455     }
7456   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7457   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7458     nreverse (tem);
7459   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7460   DECL_MAX_LOCALS (current_function_decl) = i;
7461 }
7462
7463 /* Called during parsing. Creates an artificial method declaration.  */
7464
7465 static tree
7466 create_artificial_method (tree class, int flags, tree type,
7467                           tree name, tree args)
7468 {
7469   tree mdecl;
7470
7471   java_parser_context_save_global ();
7472   input_line = 0;
7473   mdecl = make_node (FUNCTION_TYPE);
7474   TREE_TYPE (mdecl) = type;
7475   TYPE_ARG_TYPES (mdecl) = args;
7476   mdecl = add_method (class, flags, name, build_java_signature (mdecl));
7477   java_parser_context_restore_global ();
7478   DECL_ARTIFICIAL (mdecl) = 1;
7479   return mdecl;
7480 }
7481
7482 /* Starts the body if an artificial method.  */
7483
7484 static void
7485 start_artificial_method_body (tree mdecl)
7486 {
7487   DECL_SOURCE_LINE (mdecl) = 1;
7488   DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7489   source_start_java_method (mdecl);
7490   enter_block ();
7491 }
7492
7493 static void
7494 end_artificial_method_body (tree mdecl)
7495 {
7496   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7497      It has to be evaluated first. (if mdecl is current_function_decl,
7498      we have an undefined behavior if no temporary variable is used.) */
7499   tree b = exit_block ();
7500   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7501   exit_block ();
7502 }
7503
7504 /* Dump a tree of some kind.  This is a convenience wrapper for the
7505    dump_* functions in tree-dump.c.  */
7506 static void
7507 dump_java_tree (enum tree_dump_index phase, tree t)
7508 {
7509   FILE *stream;
7510   int flags;
7511
7512   stream = dump_begin (phase, &flags);
7513   flags |= TDF_SLIM;
7514   if (stream)
7515     {
7516       dump_node (t, flags, stream);
7517       dump_end (phase, stream);
7518     }
7519 }
7520
7521 /* Terminate a function and expand its body.  */
7522
7523 static void
7524 source_end_java_method (void)
7525 {
7526   tree fndecl = current_function_decl;
7527
7528   if (!fndecl)
7529     return;
7530
7531   java_parser_context_save_global ();
7532   input_line = ctxp->last_ccb_indent1;
7533
7534   /* Turn function bodies with only a NOP expr null, so they don't get
7535      generated at all and we won't get warnings when using the -W
7536      -Wall flags. */
7537   if (IS_EMPTY_STMT (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))))
7538     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7539
7540   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
7541       && ! flag_emit_class_files
7542       && ! flag_emit_xref)
7543     finish_method (fndecl);
7544
7545   current_function_decl = NULL_TREE;
7546   java_parser_context_restore_global ();
7547   current_function_decl = NULL_TREE;
7548 }
7549
7550 /* Record EXPR in the current function block. Complements compound
7551    expression second operand if necessary.  */
7552
7553 tree
7554 java_method_add_stmt (tree fndecl, tree expr)
7555 {
7556   if (!GET_CURRENT_BLOCK (fndecl))
7557     return NULL_TREE;
7558   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7559 }
7560
7561 static tree
7562 add_stmt_to_block (tree b, tree type, tree stmt)
7563 {
7564   tree body = BLOCK_EXPR_BODY (b), c;
7565
7566   if (java_error_count)
7567     return body;
7568
7569   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7570     return body;
7571
7572   BLOCK_EXPR_BODY (b) = c;
7573   TREE_SIDE_EFFECTS (c) = 1;
7574   return c;
7575 }
7576
7577 /* Lays out the methods for the classes seen so far.  */
7578
7579 void
7580 java_layout_seen_class_methods (void)
7581 {
7582   tree previous_list = all_class_list;
7583   tree end = NULL_TREE;
7584   tree current;
7585
7586   while (1)
7587     {
7588       for (current = previous_list;
7589            current != end; current = TREE_CHAIN (current))
7590         {
7591           tree cls = TREE_TYPE (TREE_VALUE (current));
7592
7593           if (! CLASS_LOADED_P (cls))
7594             load_class (cls, 0);
7595
7596           layout_class_methods (cls);
7597         }
7598
7599       /* Note that new classes might have been added while laying out
7600          methods, changing the value of all_class_list.  */
7601
7602       if (previous_list != all_class_list)
7603         {
7604           end = previous_list;
7605           previous_list = all_class_list;
7606         }
7607       else
7608         break;
7609     }
7610 }
7611
7612 static GTY(()) tree stop_reordering;
7613 void
7614 java_reorder_fields (void)
7615 {
7616   tree current;
7617
7618   for (current = gclass_list; current; current = TREE_CHAIN (current))
7619     {
7620       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7621
7622       if (current_class == stop_reordering)
7623         break;
7624
7625       /* Reverse the fields, but leave the dummy field in front.
7626          Fields are already ordered for Object and Class */
7627       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7628           && current_class != class_type_node)
7629       {
7630         /* If the dummy field is there, reverse the right fields and
7631            just layout the type for proper fields offset */
7632         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7633           {
7634             tree fields = TYPE_FIELDS (current_class);
7635             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7636             TYPE_SIZE (current_class) = NULL_TREE;
7637           }
7638         /* We don't have a dummy field, we need to layout the class,
7639            after having reversed the fields */
7640         else
7641           {
7642             TYPE_FIELDS (current_class) =
7643               nreverse (TYPE_FIELDS (current_class));
7644             TYPE_SIZE (current_class) = NULL_TREE;
7645           }
7646       }
7647     }
7648   /* There are cases were gclass_list will be empty. */
7649   if (gclass_list)
7650     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7651 }
7652
7653 /* Layout the methods of all classes loaded in one way or another.
7654    Check methods of source parsed classes. Then reorder the
7655    fields and layout the classes or the type of all source parsed
7656    classes */
7657
7658 void
7659 java_layout_classes (void)
7660 {
7661   tree current;
7662   int save_error_count = java_error_count;
7663
7664   /* Layout the methods of all classes seen so far */
7665   java_layout_seen_class_methods ();
7666   java_parse_abort_on_error ();
7667   all_class_list = NULL_TREE;
7668
7669   /* Then check the methods of all parsed classes */
7670   for (current = gclass_list; current; current = TREE_CHAIN (current))
7671     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7672       java_check_methods (TREE_VALUE (current));
7673   java_parse_abort_on_error ();
7674
7675   for (current = gclass_list; current; current = TREE_CHAIN (current))
7676     {
7677       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7678       layout_class (current_class);
7679
7680       /* Error reported by the caller */
7681       if (java_error_count)
7682         return;
7683     }
7684
7685   /* We might have reloaded classes durign the process of laying out
7686      classes for code generation. We must layout the methods of those
7687      late additions, as constructor checks might use them */
7688   java_layout_seen_class_methods ();
7689   java_parse_abort_on_error ();
7690 }
7691
7692 /* Expand methods in the current set of classes remembered for
7693    generation.  */
7694
7695 static void
7696 java_complete_expand_classes (void)
7697 {
7698   tree current;
7699
7700   do_not_fold = flag_emit_xref;
7701
7702   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7703     if (!INNER_CLASS_DECL_P (current))
7704       java_complete_expand_class (current);
7705 }
7706
7707 /* Expand the methods found in OUTER, starting first by OUTER's inner
7708    classes, if any.  */
7709
7710 static void
7711 java_complete_expand_class (tree outer)
7712 {
7713   tree inner_list;
7714
7715   set_nested_class_simple_name_value (outer, 1); /* Set */
7716
7717   /* We need to go after all inner classes and start expanding them,
7718      starting with most nested ones. We have to do that because nested
7719      classes might add functions to outer classes */
7720
7721   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7722        inner_list; inner_list = TREE_CHAIN (inner_list))
7723     java_complete_expand_class (TREE_PURPOSE (inner_list));
7724
7725   java_complete_expand_methods (outer);
7726   set_nested_class_simple_name_value (outer, 0); /* Reset */
7727 }
7728
7729 /* Expand methods registered in CLASS_DECL. The general idea is that
7730    we expand regular methods first. This allows us get an estimate on
7731    how outer context local alias fields are really used so we can add
7732    to the constructor just enough code to initialize them properly (it
7733    also lets us generate finit$ correctly.) Then we expand the
7734    constructors and then <clinit>.  */
7735
7736 static void
7737 java_complete_expand_methods (tree class_decl)
7738 {
7739   tree clinit, decl, first_decl;
7740
7741   output_class = current_class = TREE_TYPE (class_decl);
7742
7743   /* Pre-expand <clinit> to figure whether we really need it or
7744      not. If we do need it, we pre-expand the static fields so they're
7745      ready to be used somewhere else. <clinit> will be fully expanded
7746      after we processed the constructors. */
7747   first_decl = TYPE_METHODS (current_class);
7748   clinit = maybe_generate_pre_expand_clinit (current_class);
7749
7750   /* Then generate finit$ (if we need to) because constructors will
7751    try to use it.*/
7752   if (TYPE_FINIT_STMT_LIST (current_class))
7753     java_complete_expand_method (generate_finit (current_class));
7754
7755   /* Then generate instinit$ (if we need to) because constructors will
7756      try to use it. */
7757   if (TYPE_II_STMT_LIST (current_class))
7758     java_complete_expand_method (generate_instinit (current_class));
7759
7760   /* Now do the constructors */
7761   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7762     {
7763       int no_body;
7764
7765       if (!DECL_CONSTRUCTOR_P (decl))
7766         continue;
7767
7768       no_body = !DECL_FUNCTION_BODY (decl);
7769       /* Don't generate debug info on line zero when expanding a
7770          generated constructor. */
7771       if (no_body)
7772         restore_line_number_status (1);
7773
7774       java_complete_expand_method (decl);
7775
7776       if (no_body)
7777         restore_line_number_status (0);
7778     }
7779
7780   /* First, do the ordinary methods. */
7781   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7782     {
7783       /* Ctors aren't part of this batch. */
7784       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7785         continue;
7786
7787       /* Skip abstract or native methods -- but do handle native
7788          methods when generating JNI stubs.  */
7789       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7790         {
7791           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7792           continue;
7793         }
7794
7795       if (METHOD_NATIVE (decl))
7796         {
7797           tree body;
7798           current_function_decl = decl;
7799           body = build_jni_stub (decl);
7800           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7801         }
7802
7803       java_complete_expand_method (decl);
7804     }
7805
7806   /* If there is indeed a <clinit>, fully expand it now */
7807   if (clinit)
7808     {
7809       /* Prevent the use of `this' inside <clinit> */
7810       ctxp->explicit_constructor_p = 1;
7811       java_complete_expand_method (clinit);
7812       ctxp->explicit_constructor_p = 0;
7813     }
7814
7815   /* We might have generated a class$ that we now want to expand */
7816   if (TYPE_DOT_CLASS (current_class))
7817     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7818
7819   /* Now verify constructor circularity (stop after the first one we
7820      prove wrong.) */
7821   if (!CLASS_INTERFACE (class_decl))
7822     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7823       if (DECL_CONSTRUCTOR_P (decl)
7824           && verify_constructor_circularity (decl, decl))
7825         break;
7826 }
7827
7828 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7829    safely used in some other methods/constructors.  */
7830
7831 static tree
7832 maybe_generate_pre_expand_clinit (tree class_type)
7833 {
7834   tree current, mdecl;
7835
7836   if (!TYPE_CLINIT_STMT_LIST (class_type))
7837     return NULL_TREE;
7838
7839   /* Go through all static fields and pre expand them */
7840   for (current = TYPE_FIELDS (class_type); current;
7841        current = TREE_CHAIN (current))
7842     if (FIELD_STATIC (current))
7843       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7844
7845   /* Then build the <clinit> method */
7846   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7847                                     clinit_identifier_node, end_params_node);
7848   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7849                        mdecl, NULL_TREE);
7850   start_artificial_method_body (mdecl);
7851
7852   /* We process the list of assignment we produced as the result of
7853      the declaration of initialized static field and add them as
7854      statement to the <clinit> method. */
7855   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7856        current = TREE_CHAIN (current))
7857     {
7858       tree stmt = current;
7859       /* We build the assignment expression that will initialize the
7860          field to its value. There are strict rules on static
7861          initializers (8.5). FIXME */
7862       if (TREE_CODE (stmt) != BLOCK && !IS_EMPTY_STMT (stmt))
7863         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7864       java_method_add_stmt (mdecl, stmt);
7865     }
7866
7867   end_artificial_method_body (mdecl);
7868
7869   /* Now we want to place <clinit> as the last method (because we need
7870      it at least for interface so that it doesn't interfere with the
7871      dispatch table based lookup. */
7872   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7873     {
7874       current = TREE_CHAIN (TYPE_METHODS (class_type));
7875       TYPE_METHODS (class_type) = current;
7876
7877       while (TREE_CHAIN (current))
7878         current = TREE_CHAIN (current);
7879
7880       TREE_CHAIN (current) = mdecl;
7881       TREE_CHAIN (mdecl) = NULL_TREE;
7882     }
7883
7884   return mdecl;
7885 }
7886
7887 /* Analyzes a method body and look for something that isn't a
7888    MODIFY_EXPR with a constant value.  */
7889
7890 static int
7891 analyze_clinit_body (tree this_class, tree bbody)
7892 {
7893   while (bbody)
7894     switch (TREE_CODE (bbody))
7895       {
7896       case BLOCK:
7897         bbody = BLOCK_EXPR_BODY (bbody);
7898         break;
7899
7900       case EXPR_WITH_FILE_LOCATION:
7901         bbody = EXPR_WFL_NODE (bbody);
7902         break;
7903
7904       case COMPOUND_EXPR:
7905         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
7906           return 1;
7907         bbody = TREE_OPERAND (bbody, 1);
7908         break;
7909
7910       case MODIFY_EXPR:
7911         /* If we're generating to class file and we're dealing with an
7912            array initialization, we return 1 to keep <clinit> */
7913         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
7914             && flag_emit_class_files)
7915           return 1;
7916
7917         /* There are a few cases where we're required to keep
7918            <clinit>:
7919            - If this is an assignment whose operand is not constant,
7920            - If this is an assignment to a non-initialized field,
7921            - If this field is not a member of the current class.
7922         */
7923         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
7924                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
7925                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
7926
7927       default:
7928         return 1;
7929       }
7930   return 0;
7931 }
7932
7933
7934 /* See whether we could get rid of <clinit>. Criteria are: all static
7935    final fields have constant initial values and the body of <clinit>
7936    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7937
7938 static int
7939 maybe_yank_clinit (tree mdecl)
7940 {
7941   tree type, current;
7942   tree fbody, bbody;
7943
7944   if (!DECL_CLINIT_P (mdecl))
7945     return 0;
7946
7947   /* If the body isn't empty, then we keep <clinit>. Note that if
7948      we're emitting classfiles, this isn't enough not to rule it
7949      out. */
7950   fbody = DECL_FUNCTION_BODY (mdecl);
7951   bbody = BLOCK_EXPR_BODY (fbody);
7952   if (bbody && bbody != error_mark_node)
7953     bbody = BLOCK_EXPR_BODY (bbody);
7954   else
7955     return 0;
7956   if (bbody && ! flag_emit_class_files && !IS_EMPTY_STMT (bbody))
7957     return 0;
7958
7959   type = DECL_CONTEXT (mdecl);
7960   current = TYPE_FIELDS (type);
7961
7962   for (current = (current ? TREE_CHAIN (current) : current);
7963        current; current = TREE_CHAIN (current))
7964     {
7965       tree f_init;
7966
7967       /* We're not interested in non-static fields.  */
7968       if (!FIELD_STATIC (current))
7969         continue;
7970
7971       /* Nor in fields without initializers. */
7972       f_init = DECL_INITIAL (current);
7973       if (f_init == NULL_TREE)
7974         continue;
7975
7976       /* Anything that isn't String or a basic type is ruled out -- or
7977          if we know how to deal with it (when doing things natively) we
7978          should generated an empty <clinit> so that SUID are computed
7979          correctly. */
7980       if (! JSTRING_TYPE_P (TREE_TYPE (current))
7981           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
7982         return 0;
7983
7984       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
7985         return 0;
7986     }
7987
7988   /* Now we analyze the method body and look for something that
7989      isn't a MODIFY_EXPR */
7990   if (!IS_EMPTY_STMT (bbody) && analyze_clinit_body (type, bbody))
7991     return 0;
7992
7993   /* Get rid of <clinit> in the class' list of methods */
7994   if (TYPE_METHODS (type) == mdecl)
7995     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7996   else
7997     for (current = TYPE_METHODS (type); current;
7998          current = TREE_CHAIN (current))
7999       if (TREE_CHAIN (current) == mdecl)
8000         {
8001           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
8002           break;
8003         }
8004
8005   return 1;
8006 }
8007
8008 /* Install the argument from MDECL. Suitable to completion and
8009    expansion of mdecl's body.  */
8010
8011 void
8012 start_complete_expand_method (tree mdecl)
8013 {
8014   tree tem;
8015
8016   pushlevel (1);                /* Prepare for a parameter push */
8017   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
8018   DECL_ARGUMENTS (mdecl) = tem;
8019
8020   for (; tem; tem = TREE_CHAIN (tem))
8021     {
8022       /* TREE_CHAIN (tem) will change after pushdecl. */
8023       tree next = TREE_CHAIN (tem);
8024       tree type = TREE_TYPE (tem);
8025       if (targetm.calls.promote_prototypes (type)
8026           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
8027           && INTEGRAL_TYPE_P (type))
8028         type = integer_type_node;
8029       DECL_ARG_TYPE (tem) = type;
8030       layout_decl (tem, 0);
8031       pushdecl (tem);
8032       /* Re-install the next so that the list is kept and the loop
8033          advances. */
8034       TREE_CHAIN (tem) = next;
8035     }
8036   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8037   input_line = DECL_SOURCE_LINE (mdecl);
8038   build_result_decl (mdecl);
8039 }
8040
8041
8042 /* Complete and expand a method.  */
8043
8044 static void
8045 java_complete_expand_method (tree mdecl)
8046 {
8047   tree fbody, block_body, exception_copy;
8048
8049   current_function_decl = mdecl;
8050   /* Fix constructors before expanding them */
8051   if (DECL_CONSTRUCTOR_P (mdecl))
8052     fix_constructors (mdecl);
8053
8054   /* Expand functions that have a body */
8055   if (!DECL_FUNCTION_BODY (mdecl))
8056     return;
8057
8058   fbody = DECL_FUNCTION_BODY (mdecl);
8059   block_body = BLOCK_EXPR_BODY (fbody);
8060   exception_copy = NULL_TREE;
8061
8062   current_function_decl = mdecl;
8063
8064   if (! quiet_flag)
8065     fprintf (stderr, " [%s.",
8066              lang_printable_name (DECL_CONTEXT (mdecl), 0));
8067   announce_function (mdecl);
8068   if (! quiet_flag)
8069     fprintf (stderr, "]");
8070
8071   /* Prepare the function for tree completion */
8072   start_complete_expand_method (mdecl);
8073
8074   /* Install the current this */
8075   current_this = (!METHOD_STATIC (mdecl) ?
8076                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8077
8078   /* Purge the `throws' list of unchecked exceptions (we save a copy
8079      of the list and re-install it later.) */
8080   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8081   purge_unchecked_exceptions (mdecl);
8082
8083   /* Install exceptions thrown with `throws' */
8084   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8085
8086   if (block_body != NULL_TREE)
8087     {
8088       block_body = java_complete_tree (block_body);
8089
8090       /* Before we check initialization, attached all class initialization
8091          variable to the block_body */
8092       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8093                      attach_init_test_initialization_flags, block_body);
8094
8095       if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
8096         {
8097           check_for_initialization (block_body, mdecl);
8098
8099           /* Go through all the flags marking the initialization of
8100              static variables and see whether they're definitively
8101              assigned, in which case the type is remembered as
8102              definitively initialized in MDECL. */
8103           if (STATIC_CLASS_INIT_OPT_P ())
8104             {
8105               /* Always register the context as properly initialized in
8106                  MDECL. This used with caution helps removing extra
8107                  initialization of self. */
8108               if (METHOD_STATIC (mdecl))
8109                 {
8110                   *(htab_find_slot
8111                     (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8112                      DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8113                 }
8114             }
8115         }
8116       ctxp->explicit_constructor_p = 0;
8117     }
8118
8119   BLOCK_EXPR_BODY (fbody) = block_body;
8120
8121   /* If we saw a return but couldn't evaluate it properly, we'll have
8122      an error_mark_node here. */
8123   if (block_body != error_mark_node
8124       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8125       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
8126       && !flag_emit_xref)
8127     missing_return_error (current_function_decl);
8128
8129   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8130   maybe_yank_clinit (mdecl);
8131
8132   /* Pop the current level, with special measures if we found errors. */
8133   if (java_error_count)
8134     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8135   poplevel (1, 0, 1);
8136
8137   /* Pop the exceptions and sanity check */
8138   POP_EXCEPTIONS();
8139   if (currently_caught_type_list)
8140     abort ();
8141
8142   /* Restore the copy of the list of exceptions if emitting xrefs. */
8143   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8144 }
8145
8146 /* For with each class for which there's code to generate. */
8147
8148 static void
8149 java_expand_method_bodies (tree class)
8150 {
8151   tree decl;
8152   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8153     {
8154       tree block;
8155
8156       if (! DECL_FUNCTION_BODY (decl))
8157         continue;
8158
8159       current_function_decl = decl;
8160
8161       block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8162
8163       /* Save the function body for gimplify and inlining.  */
8164       DECL_SAVED_TREE (decl) = block;
8165
8166       /* It's time to assign the variable flagging static class
8167          initialization based on which classes invoked static methods
8168          are definitely initializing. This should be flagged. */
8169       if (STATIC_CLASS_INIT_OPT_P ())
8170         {
8171           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8172           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8173             {
8174               /* Executed for each statement calling a static function.
8175                  LIST is a TREE_LIST whose PURPOSE is the called function
8176                  and VALUE is a compound whose second operand can be patched
8177                  with static class initialization flag assignments.  */
8178
8179               tree called_method = TREE_PURPOSE (list);
8180               tree compound = TREE_VALUE (list);
8181               tree assignment_compound_list
8182                 = build_tree_list (called_method, NULL);
8183
8184               /* For each class definitely initialized in
8185                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8186                  assignment to the class initialization flag. */
8187               htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8188                              emit_test_initialization,
8189                              assignment_compound_list);
8190
8191               if (TREE_VALUE (assignment_compound_list))
8192                 TREE_OPERAND (compound, 1)
8193                   = TREE_VALUE (assignment_compound_list);
8194             }
8195         }
8196
8197       /* Expand the function body.  */
8198       source_end_java_method ();
8199     }
8200 }
8201
8202 \f
8203
8204 /* This section of the code deals with accessing enclosing context
8205    fields either directly by using the relevant access to this$<n> or
8206    by invoking an access method crafted for that purpose.  */
8207
8208 /* Build the necessary access from an inner class to an outer
8209    class. This routine could be optimized to cache previous result
8210    (decl, current_class and returned access).  When an access method
8211    needs to be generated, it always takes the form of a read. It might
8212    be later turned into a write by calling outer_field_access_fix.  */
8213
8214 static tree
8215 build_outer_field_access (tree id, tree decl)
8216 {
8217   tree access = NULL_TREE;
8218   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8219   tree decl_ctx = DECL_CONTEXT (decl);
8220
8221   /* If the immediate enclosing context of the current class is the
8222      field decl's class or inherits from it; build the access as
8223      `this$<n>.<field>'. Note that we will break the `private' barrier
8224      if we're not emitting bytecodes. */
8225   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8226       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8227     {
8228       tree thisn = build_current_thisn (current_class);
8229       access = make_qualified_primary (build_wfl_node (thisn),
8230                                        id, EXPR_WFL_LINECOL (id));
8231     }
8232   /* Otherwise, generate access methods to outer this and access the
8233      field (either using an access method or by direct access.) */
8234   else
8235     {
8236       int lc = EXPR_WFL_LINECOL (id);
8237
8238       /* Now we chain the required number of calls to the access$0 to
8239          get a hold to the enclosing instance we need, and then we
8240          build the field access. */
8241       access = build_access_to_thisn (current_class, decl_ctx, lc);
8242
8243       /* If the field is private and we're generating bytecode, then
8244          we generate an access method */
8245       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8246         {
8247           tree name = build_outer_field_access_methods (decl);
8248           access = build_outer_field_access_expr (lc, decl_ctx,
8249                                                   name, access, NULL_TREE);
8250         }
8251       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8252          Once again we break the `private' access rule from a foreign
8253          class. */
8254       else
8255         access = make_qualified_primary (access, id, lc);
8256     }
8257   return resolve_expression_name (access, NULL);
8258 }
8259
8260 /* Return a nonzero value if NODE describes an outer field inner
8261    access.  */
8262
8263 static int
8264 outer_field_access_p (tree type, tree decl)
8265 {
8266   if (!INNER_CLASS_TYPE_P (type)
8267       || TREE_CODE (decl) != FIELD_DECL
8268       || DECL_CONTEXT (decl) == type)
8269     return 0;
8270
8271   /* If the inner class extends the declaration context of the field
8272      we're trying to access, then this isn't an outer field access */
8273   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8274     return 0;
8275
8276   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8277        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8278     {
8279       if (type == DECL_CONTEXT (decl))
8280         return 1;
8281
8282       if (!DECL_CONTEXT (TYPE_NAME (type)))
8283         {
8284           /* Before we give up, see whether the field is inherited from
8285              the enclosing context we're considering. */
8286           if (inherits_from_p (type, DECL_CONTEXT (decl)))
8287             return 1;
8288           break;
8289         }
8290     }
8291
8292   return 0;
8293 }
8294
8295 /* Return a nonzero value if NODE represents an outer field inner
8296    access that was been already expanded. As a side effect, it returns
8297    the name of the field being accessed and the argument passed to the
8298    access function, suitable for a regeneration of the access method
8299    call if necessary. */
8300
8301 static int
8302 outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8303                                tree *arg)
8304 {
8305   int identified = 0;
8306
8307   if (TREE_CODE (node) != CALL_EXPR)
8308     return 0;
8309
8310   /* Well, gcj generates slightly different tree nodes when compiling
8311      to native or bytecodes. It's the case for function calls. */
8312
8313   if (flag_emit_class_files
8314       && TREE_CODE (node) == CALL_EXPR
8315       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8316     identified = 1;
8317   else if (!flag_emit_class_files)
8318     {
8319       node = TREE_OPERAND (node, 0);
8320
8321       if (node && TREE_OPERAND (node, 0)
8322           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8323         {
8324           node = TREE_OPERAND (node, 0);
8325           if (TREE_OPERAND (node, 0)
8326               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8327               && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8328                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8329             identified = 1;
8330         }
8331     }
8332
8333   if (identified && name && arg_type && arg)
8334     {
8335       tree argument = TREE_OPERAND (node, 1);
8336       *name = DECL_NAME (TREE_OPERAND (node, 0));
8337       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8338       *arg = TREE_VALUE (argument);
8339     }
8340   return identified;
8341 }
8342
8343 /* Detect in NODE an outer field read access from an inner class and
8344    transform it into a write with RHS as an argument. This function is
8345    called from the java_complete_lhs when an assignment to a LHS can
8346    be identified. */
8347
8348 static tree
8349 outer_field_access_fix (tree wfl, tree node, tree rhs)
8350 {
8351   tree name, arg_type, arg;
8352
8353   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8354     {
8355       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8356                                             arg_type, name, arg, rhs);
8357       return java_complete_tree (node);
8358     }
8359   return NULL_TREE;
8360 }
8361
8362 /* Construct the expression that calls an access method:
8363      <type>.access$<n>(<arg1> [, <arg2>]);
8364
8365    ARG2 can be NULL and will be omitted in that case. It will denote a
8366    read access.  */
8367
8368 static tree
8369 build_outer_field_access_expr (int lc, tree type, tree access_method_name,
8370                                tree arg1, tree arg2)
8371 {
8372   tree args, cn, access;
8373
8374   args = arg1 ? arg1 :
8375     build_wfl_node (build_current_thisn (current_class));
8376   args = build_tree_list (NULL_TREE, args);
8377
8378   if (arg2)
8379     args = tree_cons (NULL_TREE, arg2, args);
8380
8381   access = build_method_invocation (build_wfl_node (access_method_name), args);
8382   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8383   return make_qualified_primary (cn, access, lc);
8384 }
8385
8386 static tree
8387 build_new_access_id (void)
8388 {
8389   static int access_n_counter = 1;
8390   char buffer [128];
8391
8392   sprintf (buffer, "access$%d", access_n_counter++);
8393   return get_identifier (buffer);
8394 }
8395
8396 /* Create the static access functions for the outer field DECL. We define a
8397    read:
8398      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8399        return inst$.field;
8400      }
8401    and a write access:
8402      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8403                                      TREE_TYPE (<field>) value$) {
8404        return inst$.field = value$;
8405      }
8406    We should have a usage flags on the DECL so we can lazily turn the ones
8407    we're using for code generation. FIXME.
8408 */
8409
8410 static tree
8411 build_outer_field_access_methods (tree decl)
8412 {
8413   tree id, args, stmt, mdecl;
8414
8415   if (FIELD_INNER_ACCESS_P (decl))
8416     return FIELD_INNER_ACCESS (decl);
8417
8418   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8419
8420   /* Create the identifier and a function named after it. */
8421   id = build_new_access_id ();
8422
8423   /* The identifier is marked as bearing the name of a generated write
8424      access function for outer field accessed from inner classes. */
8425   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8426
8427   /* Create the read access */
8428   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8429   TREE_CHAIN (args) = end_params_node;
8430   stmt = make_qualified_primary (build_wfl_node (inst_id),
8431                                  build_wfl_node (DECL_NAME (decl)), 0);
8432   stmt = build_return (0, stmt);
8433   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8434                                            TREE_TYPE (decl), id, args, stmt);
8435   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8436
8437   /* Create the write access method. No write access for final variable */
8438   if (!FIELD_FINAL (decl))
8439     {
8440       args = build_tree_list (inst_id,
8441                               build_pointer_type (DECL_CONTEXT (decl)));
8442       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8443       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8444       stmt = make_qualified_primary (build_wfl_node (inst_id),
8445                                      build_wfl_node (DECL_NAME (decl)), 0);
8446       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8447                                                 build_wfl_node (wpv_id)));
8448       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8449                                                TREE_TYPE (decl), id,
8450                                                args, stmt);
8451     }
8452   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8453
8454   /* Return the access name */
8455   return FIELD_INNER_ACCESS (decl) = id;
8456 }
8457
8458 /* Build an field access method NAME.  */
8459
8460 static tree
8461 build_outer_field_access_method (tree class, tree type, tree name,
8462                                  tree args, tree body)
8463 {
8464   tree saved_current_function_decl, mdecl;
8465
8466   /* Create the method */
8467   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8468   fix_method_argument_names (args, mdecl);
8469   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8470
8471   /* Attach the method body. */
8472   saved_current_function_decl = current_function_decl;
8473   start_artificial_method_body (mdecl);
8474   java_method_add_stmt (mdecl, body);
8475   end_artificial_method_body (mdecl);
8476   current_function_decl = saved_current_function_decl;
8477
8478   return mdecl;
8479 }
8480
8481 \f
8482 /* This section deals with building access function necessary for
8483    certain kinds of method invocation from inner classes.  */
8484
8485 static tree
8486 build_outer_method_access_method (tree decl)
8487 {
8488   tree saved_current_function_decl, mdecl;
8489   tree args = NULL_TREE, call_args = NULL_TREE;
8490   tree carg, id, body, class;
8491   char buffer [80];
8492   int parm_id_count = 0;
8493
8494   /* Test this abort with an access to a private field */
8495   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8496     abort ();
8497
8498   /* Check the cache first */
8499   if (DECL_FUNCTION_INNER_ACCESS (decl))
8500     return DECL_FUNCTION_INNER_ACCESS (decl);
8501
8502   class = DECL_CONTEXT (decl);
8503
8504   /* Obtain an access identifier and mark it */
8505   id = build_new_access_id ();
8506   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8507
8508   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8509   /* Create the arguments, as much as the original */
8510   for (; carg && carg != end_params_node;
8511        carg = TREE_CHAIN (carg))
8512     {
8513       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8514       args = chainon (args, build_tree_list (get_identifier (buffer),
8515                                              TREE_VALUE (carg)));
8516     }
8517   args = chainon (args, end_params_node);
8518
8519   /* Create the method */
8520   mdecl = create_artificial_method (class, ACC_STATIC,
8521                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8522   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8523   /* There is a potential bug here. We should be able to use
8524      fix_method_argument_names, but then arg names get mixed up and
8525      eventually a constructor will have its this$0 altered and the
8526      outer context won't be assignment properly. The testcase is
8527      stub.java FIXME */
8528   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8529
8530   /* Attach the method body. */
8531   saved_current_function_decl = current_function_decl;
8532   start_artificial_method_body (mdecl);
8533
8534   /* The actual method invocation uses the same args. When invoking a
8535      static methods that way, we don't want to skip the first
8536      argument. */
8537   carg = args;
8538   if (!METHOD_STATIC (decl))
8539     carg = TREE_CHAIN (carg);
8540   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8541     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8542                            call_args);
8543
8544   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8545                                   call_args);
8546   if (!METHOD_STATIC (decl))
8547     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8548                                    body, 0);
8549   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8550     body = build_return (0, body);
8551   java_method_add_stmt (mdecl,body);
8552   end_artificial_method_body (mdecl);
8553   current_function_decl = saved_current_function_decl;
8554
8555   /* Back tag the access function so it know what it accesses */
8556   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8557
8558   /* Tag the current method so it knows it has an access generated */
8559   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8560 }
8561
8562 \f
8563 /* This section of the code deals with building expressions to access
8564    the enclosing instance of an inner class. The enclosing instance is
8565    kept in a generated field called this$<n>, with <n> being the
8566    inner class nesting level (starting from 0.)  */
8567
8568 /* Build an access to a given this$<n>, always chaining access call to
8569    others. Access methods to this$<n> are build on the fly if
8570    necessary. This CAN'T be used to solely access this$<n-1> from
8571    this$<n> (which alway yield to special cases and optimization, see
8572    for example build_outer_field_access).  */
8573
8574 static tree
8575 build_access_to_thisn (tree from, tree to, int lc)
8576 {
8577   tree access = NULL_TREE;
8578
8579   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8580     {
8581       if (!access)
8582         {
8583           access = build_current_thisn (from);
8584           access = build_wfl_node (access);
8585         }
8586       else
8587         {
8588           tree access0_wfl, cn;
8589
8590           maybe_build_thisn_access_method (from);
8591           access0_wfl = build_wfl_node (access0_identifier_node);
8592           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8593           EXPR_WFL_LINECOL (access0_wfl) = lc;
8594           access = build_tree_list (NULL_TREE, access);
8595           access = build_method_invocation (access0_wfl, access);
8596           access = make_qualified_primary (cn, access, lc);
8597         }
8598
8599       /* If FROM isn't an inner class, that's fine, we've done enough.
8600          What we're looking for can be accessed from there.  */
8601       from = DECL_CONTEXT (TYPE_NAME (from));
8602       if (!from)
8603         break;
8604       from = TREE_TYPE (from);
8605     }
8606   return access;
8607 }
8608
8609 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8610    is returned if nothing needs to be generated. Otherwise, the method
8611    generated and a method decl is returned.
8612
8613    NOTE: These generated methods should be declared in a class file
8614    attribute so that they can't be referred to directly.  */
8615
8616 static tree
8617 maybe_build_thisn_access_method (tree type)
8618 {
8619   tree mdecl, args, stmt, rtype;
8620   tree saved_current_function_decl;
8621
8622   /* If TYPE is a top-level class, no access method is required.
8623      If there already is such an access method, bail out. */
8624   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8625     return NULL_TREE;
8626
8627   /* We generate the method. The method looks like:
8628      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8629   */
8630   args = build_tree_list (inst_id, build_pointer_type (type));
8631   TREE_CHAIN (args) = end_params_node;
8632   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8633   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8634                                     access0_identifier_node, args);
8635   fix_method_argument_names (args, mdecl);
8636   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8637   stmt = build_current_thisn (type);
8638   stmt = make_qualified_primary (build_wfl_node (inst_id),
8639                                  build_wfl_node (stmt), 0);
8640   stmt = build_return (0, stmt);
8641
8642   saved_current_function_decl = current_function_decl;
8643   start_artificial_method_body (mdecl);
8644   java_method_add_stmt (mdecl, stmt);
8645   end_artificial_method_body (mdecl);
8646   current_function_decl = saved_current_function_decl;
8647
8648   CLASS_ACCESS0_GENERATED_P (type) = 1;
8649
8650   return mdecl;
8651 }
8652
8653 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8654    the first level of innerclassing. this$1 for the next one, etc...
8655    This function can be invoked with TYPE to NULL, available and then
8656    has to count the parser context.  */
8657
8658 static GTY(()) tree saved_thisn;
8659 static GTY(()) tree saved_type;
8660
8661 static tree
8662 build_current_thisn (tree type)
8663 {
8664   static int saved_i = -1;
8665   static int saved_type_i = 0;
8666   tree decl;
8667   char buffer [24];
8668   int i = 0;
8669
8670   if (type)
8671     {
8672       if (type == saved_type)
8673         i = saved_type_i;
8674       else
8675         {
8676           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8677                decl; decl = DECL_CONTEXT (decl), i++)
8678             ;
8679
8680           saved_type = type;
8681           saved_type_i = i;
8682         }
8683     }
8684   else
8685     i = list_length (GET_CPC_LIST ())-2;
8686
8687   if (i == saved_i)
8688     return saved_thisn;
8689
8690   sprintf (buffer, "this$%d", i);
8691   saved_i = i;
8692   saved_thisn = get_identifier (buffer);
8693   return saved_thisn;
8694 }
8695
8696 /* Return the assignment to the hidden enclosing context `this$<n>'
8697    by the second incoming parameter to the innerclass constructor. The
8698    form used is `this.this$<n> = this$<n>;'.  */
8699
8700 static tree
8701 build_thisn_assign (void)
8702 {
8703   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8704     {
8705       tree thisn = build_current_thisn (current_class);
8706       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8707                                          build_wfl_node (thisn), 0);
8708       tree rhs = build_wfl_node (thisn);
8709       EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8710       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8711     }
8712   return NULL_TREE;
8713 }
8714
8715 \f
8716 /* Building the synthetic `class$' used to implement the `.class' 1.1
8717    extension for non primitive types. This method looks like:
8718
8719     static Class class$(String type) throws NoClassDefFoundError
8720     {
8721       try {return (java.lang.Class.forName (String));}
8722       catch (ClassNotFoundException e) {
8723         throw new NoClassDefFoundError(e.getMessage());}
8724     } */
8725
8726 static GTY(()) tree get_message_wfl;
8727 static GTY(()) tree type_parm_wfl;
8728
8729 static tree
8730 build_dot_class_method (tree class)
8731 {
8732 #define BWF(S) build_wfl_node (get_identifier ((S)))
8733 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8734   tree args, tmp, saved_current_function_decl, mdecl, qual_name;
8735   tree stmt, throw_stmt;
8736
8737   if (!get_message_wfl)
8738     {
8739       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8740       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8741     }
8742
8743   /* Build the arguments */
8744   args = build_tree_list (get_identifier ("type$"),
8745                           build_pointer_type (string_type_node));
8746   TREE_CHAIN (args) = end_params_node;
8747
8748   /* Build the qualified name java.lang.Class.forName */
8749   tmp = MQN (MQN (MQN (BWF ("java"),
8750                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8751
8752   /* Create the "class$" function */
8753   mdecl = create_artificial_method (class, ACC_STATIC,
8754                                     build_pointer_type (class_type_node),
8755                                     classdollar_identifier_node, args);
8756   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8757                    BWF ("NoClassDefFoundError"));
8758   DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE, qual_name);
8759   register_incomplete_type (JDEP_EXCEPTION, qual_name, NULL_TREE, NULL_TREE);
8760   JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
8761     &TREE_VALUE (DECL_FUNCTION_THROWS (mdecl));
8762
8763   /* We start by building the try block. We need to build:
8764        return (java.lang.Class.forName (type)); */
8765   stmt = build_method_invocation (tmp,
8766                                   build_tree_list (NULL_TREE, type_parm_wfl));
8767   stmt = build_return (0, stmt);
8768
8769   /* Now onto the catch block. We start by building the expression
8770      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8771   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8772                                     get_message_wfl, 0);
8773   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8774
8775   /* Build new NoClassDefFoundError (_.getMessage) */
8776   throw_stmt = build_new_invocation
8777     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8778      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8779
8780   /* Build the throw, (it's too early to use BUILD_THROW) */
8781   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8782
8783   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8784   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8785                    BWF ("ClassNotFoundException"));
8786   stmt = encapsulate_with_try_catch (0, qual_name, stmt, throw_stmt);
8787
8788   fix_method_argument_names (args, mdecl);
8789   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8790   saved_current_function_decl = current_function_decl;
8791   start_artificial_method_body (mdecl);
8792   java_method_add_stmt (mdecl, stmt);
8793   end_artificial_method_body (mdecl);
8794   current_function_decl = saved_current_function_decl;
8795   TYPE_DOT_CLASS (class) = mdecl;
8796
8797   return mdecl;
8798 }
8799
8800 static tree
8801 build_dot_class_method_invocation (tree this_class, tree type)
8802 {
8803   tree dot_class_method = TYPE_DOT_CLASS (this_class);
8804   tree sig_id, s, t;
8805
8806   if (TYPE_ARRAY_P (type))
8807     sig_id = build_java_signature (type);
8808   else
8809     sig_id = DECL_NAME (TYPE_NAME (type));
8810
8811   /* Ensure that the proper name separator is used */
8812   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8813                                IDENTIFIER_LENGTH (sig_id));
8814
8815   s = build_string (IDENTIFIER_LENGTH (sig_id),
8816                     IDENTIFIER_POINTER (sig_id));
8817   t = build_method_invocation (build_wfl_node (DECL_NAME (dot_class_method)),
8818                                build_tree_list (NULL_TREE, s));
8819   if (DECL_CONTEXT (dot_class_method) != this_class)
8820     {
8821       tree class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (dot_class_method)));
8822       t = make_qualified_primary (build_wfl_node (class_name), t, 0);
8823     }
8824   return t;
8825 }
8826
8827 /* This section of the code deals with constructor.  */
8828
8829 /* Craft a body for default constructor. Patch existing constructor
8830    bodies with call to super() and field initialization statements if
8831    necessary.  */
8832
8833 static void
8834 fix_constructors (tree mdecl)
8835 {
8836   tree iii;                     /* Instance Initializer Invocation */
8837   tree body = DECL_FUNCTION_BODY (mdecl);
8838   tree thisn_assign, compound = NULL_TREE;
8839   tree class_type = DECL_CONTEXT (mdecl);
8840
8841   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8842     return;
8843   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8844
8845   if (!body)
8846     {
8847       /* It is an error for the compiler to generate a default
8848          constructor if the superclass doesn't have a constructor that
8849          takes no argument, or the same args for an anonymous class */
8850       if (verify_constructor_super (mdecl))
8851         {
8852           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8853           tree save = DECL_NAME (mdecl);
8854           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8855           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8856           parse_error_context
8857             (lookup_cl (TYPE_NAME (class_type)),
8858              "No constructor matching `%s' found in class `%s'",
8859              lang_printable_name (mdecl, 0), n);
8860           DECL_NAME (mdecl) = save;
8861         }
8862
8863       /* The constructor body must be crafted by hand. It's the
8864          constructor we defined when we realize we didn't have the
8865          CLASSNAME() constructor */
8866       start_artificial_method_body (mdecl);
8867
8868       /* Insert an assignment to the this$<n> hidden field, if
8869          necessary */
8870       if ((thisn_assign = build_thisn_assign ()))
8871         java_method_add_stmt (mdecl, thisn_assign);
8872
8873       /* We don't generate a super constructor invocation if we're
8874          compiling java.lang.Object. build_super_invocation takes care
8875          of that. */
8876       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8877
8878       /* FIXME */
8879       if ((iii = build_instinit_invocation (class_type)))
8880         java_method_add_stmt (mdecl, iii);
8881
8882       end_artificial_method_body (mdecl);
8883     }
8884   /* Search for an explicit constructor invocation */
8885   else
8886     {
8887       int found = 0;
8888       int invokes_this = 0;
8889       tree found_call = NULL_TREE;
8890       tree main_block = BLOCK_EXPR_BODY (body);
8891
8892       while (body)
8893         switch (TREE_CODE (body))
8894           {
8895           case CALL_EXPR:
8896             found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8897             if (CALL_THIS_CONSTRUCTOR_P (body))
8898               invokes_this = 1;
8899             body = NULL_TREE;
8900             break;
8901           case COMPOUND_EXPR:
8902           case EXPR_WITH_FILE_LOCATION:
8903             found_call = body;
8904             body = TREE_OPERAND (body, 0);
8905             break;
8906           case BLOCK:
8907             found_call = body;
8908             body = BLOCK_EXPR_BODY (body);
8909             break;
8910           default:
8911             found = 0;
8912             body = NULL_TREE;
8913           }
8914
8915       /* Generate the assignment to this$<n>, if necessary */
8916       if ((thisn_assign = build_thisn_assign ()))
8917         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8918
8919       /* The constructor is missing an invocation of super() */
8920       if (!found)
8921         compound = add_stmt_to_compound (compound, NULL_TREE,
8922                                          build_super_invocation (mdecl));
8923       /* Explicit super() invocation should take place before the
8924          instance initializer blocks. */
8925       else
8926         {
8927           compound = add_stmt_to_compound (compound, NULL_TREE,
8928                                            TREE_OPERAND (found_call, 0));
8929           TREE_OPERAND (found_call, 0) = build_java_empty_stmt ();
8930         }
8931
8932       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
8933
8934       /* Insert the instance initializer block right after. */
8935       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
8936         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
8937
8938       /* Fix the constructor main block if we're adding extra stmts */
8939       if (compound)
8940         {
8941           compound = add_stmt_to_compound (compound, NULL_TREE,
8942                                            BLOCK_EXPR_BODY (main_block));
8943           BLOCK_EXPR_BODY (main_block) = compound;
8944         }
8945     }
8946 }
8947
8948 /* Browse constructors in the super class, searching for a constructor
8949    that doesn't take any argument. Return 0 if one is found, 1
8950    otherwise.  If the current class is an anonymous inner class, look
8951    for something that has the same signature. */
8952
8953 static int
8954 verify_constructor_super (tree mdecl)
8955 {
8956   tree class = CLASSTYPE_SUPER (current_class);
8957   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8958   tree sdecl;
8959
8960   if (!class)
8961     return 0;
8962
8963   if (ANONYMOUS_CLASS_P (current_class))
8964     {
8965       tree mdecl_arg_type;
8966       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8967       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8968         if (DECL_CONSTRUCTOR_P (sdecl))
8969           {
8970             tree m_arg_type;
8971             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8972             if (super_inner)
8973               arg_type = TREE_CHAIN (arg_type);
8974             for (m_arg_type = mdecl_arg_type;
8975                  (arg_type != end_params_node
8976                   && m_arg_type != end_params_node);
8977                  arg_type = TREE_CHAIN (arg_type),
8978                    m_arg_type = TREE_CHAIN (m_arg_type))
8979               if (!valid_method_invocation_conversion_p
8980                      (TREE_VALUE (arg_type),
8981                       TREE_VALUE (m_arg_type)))
8982                 break;
8983
8984             if (arg_type == end_params_node && m_arg_type == end_params_node)
8985               return 0;
8986           }
8987     }
8988   else
8989     {
8990       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8991         {
8992           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8993           if (super_inner)
8994             arg = TREE_CHAIN (arg);
8995           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
8996             return 0;
8997         }
8998     }
8999   return 1;
9000 }
9001
9002 /* Generate code for all context remembered for code generation.  */
9003
9004 static GTY(()) tree reversed_class_list;
9005 void
9006 java_expand_classes (void)
9007 {
9008   int save_error_count = 0;
9009   static struct parser_ctxt *cur_ctxp = NULL;
9010
9011   java_parse_abort_on_error ();
9012   if (!(ctxp = ctxp_for_generation))
9013     return;
9014   java_layout_classes ();
9015   java_parse_abort_on_error ();
9016
9017   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9018     {
9019       tree current;
9020       for (current = cur_ctxp->class_list;
9021            current;
9022            current = TREE_CHAIN (current))
9023         gen_indirect_dispatch_tables (TREE_TYPE (current));
9024     }
9025
9026   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9027     {
9028       ctxp = cur_ctxp;
9029       input_filename = ctxp->filename;
9030       lang_init_source (2);            /* Error msgs have method prototypes */
9031       java_complete_expand_classes (); /* Complete and expand classes */
9032       java_parse_abort_on_error ();
9033     }
9034   input_filename = main_input_filename;
9035
9036   /* Find anonymous classes and expand their constructor. This extra pass is
9037      necessary because the constructor itself is only generated when the
9038      method in which it is defined is expanded. */
9039   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9040     {
9041       tree current;
9042       ctxp = cur_ctxp;
9043       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9044         {
9045           output_class = current_class = TREE_TYPE (current);
9046           if (ANONYMOUS_CLASS_P (current_class))
9047             {
9048               tree d;
9049               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9050                 {
9051                   if (DECL_CONSTRUCTOR_P (d))
9052                     {
9053                       restore_line_number_status (1);
9054                       java_complete_expand_method (d);
9055                       restore_line_number_status (0);
9056                       break;    /* There is only one constructor. */
9057                     }
9058                 }
9059             }
9060         }
9061     }
9062
9063   /* Expanding the constructors of anonymous classes generates access
9064      methods.  Scan all the methods looking for null DECL_RESULTs --
9065      this will be the case if a method hasn't been expanded.  */
9066   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9067     {
9068       tree current;
9069       ctxp = cur_ctxp;
9070       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9071         {
9072           tree d;
9073           output_class = current_class = TREE_TYPE (current);
9074           for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9075             {
9076               if (DECL_RESULT (d) == NULL_TREE)
9077                 {
9078                   restore_line_number_status (1);
9079                   java_complete_expand_method (d);
9080                   restore_line_number_status (0);
9081                 }
9082             }
9083         }
9084     }
9085
9086   /* ???  Instead of all this we could iterate around the list of
9087      classes until there were no more un-expanded methods.  It would
9088      take a little longer -- one pass over the whole list of methods
9089      -- but it would be simpler.  Like this:  */
9090 #if 0
9091     {
9092       int something_changed;
9093
9094       do
9095         {
9096           something_changed = 0;
9097           for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9098             {
9099               tree current;
9100               ctxp = cur_ctxp;
9101               for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9102                 {
9103                   tree d;
9104                   output_class = current_class = TREE_TYPE (current);
9105                   for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9106                     {
9107                       if (DECL_RESULT (d) == NULL_TREE)
9108                         {
9109                           something_changed = 1;
9110                           restore_line_number_status (1);
9111                           java_complete_expand_method (d);
9112                           restore_line_number_status (0);
9113                         }
9114                     }
9115                 }
9116             }
9117         }
9118       while (something_changed);
9119     }
9120 #endif
9121
9122   /* If we've found error at that stage, don't try to generate
9123      anything, unless we're emitting xrefs or checking the syntax only
9124      (but not using -fsyntax-only for the purpose of generating
9125      bytecode. */
9126   if (java_error_count && !flag_emit_xref
9127       && (!flag_syntax_only && !flag_emit_class_files))
9128     return;
9129
9130   /* Now things are stable, go for generation of the class data. */
9131
9132   /* We pessimistically marked all methods and fields external until
9133      we knew what set of classes we were planning to compile.  Now mark
9134      those that will be generated locally as not external.  */
9135   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9136     {
9137       tree current;
9138       ctxp = cur_ctxp;
9139       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9140         java_mark_class_local (TREE_TYPE (current));
9141     }
9142
9143   /* Compile the classes.  */
9144   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9145     {
9146       tree current;
9147       reversed_class_list = NULL;
9148
9149       ctxp = cur_ctxp;
9150
9151       /* We write out the classes in reverse order.  This ensures that
9152          inner classes are written before their containing classes,
9153          which is important for parallel builds.  Otherwise, the
9154          class file for the outer class may be found, but the class
9155          file for the inner class may not be present.  In that
9156          situation, the compiler cannot fall back to the original
9157          source, having already read the outer class, so we must
9158          prevent that situation.  */
9159       for (current = ctxp->class_list;
9160            current;
9161            current = TREE_CHAIN (current))
9162         reversed_class_list
9163           = tree_cons (NULL_TREE, current, reversed_class_list);
9164
9165       for (current = reversed_class_list;
9166            current;
9167            current = TREE_CHAIN (current))
9168         {
9169           output_class = current_class = TREE_TYPE (TREE_VALUE (current));
9170           if (flag_emit_class_files)
9171             write_classfile (current_class);
9172           if (flag_emit_xref)
9173             expand_xref (current_class);
9174           else if (! flag_syntax_only)
9175             java_expand_method_bodies (current_class);
9176         }
9177     }
9178 }
9179
9180 void
9181 java_finish_classes (void)
9182 {
9183   static struct parser_ctxt *cur_ctxp = NULL;
9184   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9185     {
9186       tree current;
9187       ctxp = cur_ctxp;
9188       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9189         {
9190           output_class = current_class = TREE_TYPE (current);
9191           finish_class ();
9192         }
9193     }
9194 }
9195
9196 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9197    a tree list node containing RIGHT. Fore coming RIGHTs will be
9198    chained to this hook. LOCATION contains the location of the
9199    separating `.' operator.  */
9200
9201 static tree
9202 make_qualified_primary (tree primary, tree right, int location)
9203 {
9204   tree wfl;
9205
9206   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9207     wfl = build_wfl_wrap (primary, location);
9208   else
9209     {
9210       wfl = primary;
9211       /* If wfl wasn't qualified, we build a first anchor */
9212       if (!EXPR_WFL_QUALIFICATION (wfl))
9213         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9214     }
9215
9216   /* And chain them */
9217   EXPR_WFL_LINECOL (right) = location;
9218   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9219   PRIMARY_P (wfl) =  1;
9220   return wfl;
9221 }
9222
9223 /* Simple merge of two name separated by a `.' */
9224
9225 static tree
9226 merge_qualified_name (tree left, tree right)
9227 {
9228   tree node;
9229   if (!left && !right)
9230     return NULL_TREE;
9231
9232   if (!left)
9233     return right;
9234
9235   if (!right)
9236     return left;
9237
9238   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9239                 IDENTIFIER_LENGTH (left));
9240   obstack_1grow (&temporary_obstack, '.');
9241   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9242                  IDENTIFIER_LENGTH (right));
9243   node =  get_identifier (obstack_base (&temporary_obstack));
9244   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9245   QUALIFIED_P (node) = 1;
9246   return node;
9247 }
9248
9249 /* Merge the two parts of a qualified name into LEFT.  Set the
9250    location information of the resulting node to LOCATION, usually
9251    inherited from the location information of the `.' operator. */
9252
9253 static tree
9254 make_qualified_name (tree left, tree right, int location)
9255 {
9256 #ifdef USE_COMPONENT_REF
9257   tree node = build (COMPONENT_REF, NULL_TREE, left, right, NULL_TREE);
9258   EXPR_WFL_LINECOL (node) = location;
9259   return node;
9260 #else
9261   tree left_id = EXPR_WFL_NODE (left);
9262   tree right_id = EXPR_WFL_NODE (right);
9263   tree wfl, merge;
9264
9265   merge = merge_qualified_name (left_id, right_id);
9266
9267   /* Left wasn't qualified and is now qualified */
9268   if (!QUALIFIED_P (left_id))
9269     {
9270       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9271       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9272       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9273     }
9274
9275   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9276   EXPR_WFL_LINECOL (wfl) = location;
9277   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9278
9279   EXPR_WFL_NODE (left) = merge;
9280   return left;
9281 #endif
9282 }
9283
9284 /* Extract the last identifier component of the qualified in WFL. The
9285    last identifier is removed from the linked list */
9286
9287 static tree
9288 cut_identifier_in_qualified (tree wfl)
9289 {
9290   tree q;
9291   tree previous = NULL_TREE;
9292   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9293     if (!TREE_CHAIN (q))
9294       {
9295         if (!previous)
9296           /* Operating on a non qualified qualified WFL.  */
9297           abort ();
9298
9299         TREE_CHAIN (previous) = NULL_TREE;
9300         return TREE_PURPOSE (q);
9301       }
9302 }
9303
9304 /* Resolve the expression name NAME. Return its decl.  */
9305
9306 static tree
9307 resolve_expression_name (tree id, tree *orig)
9308 {
9309   tree name = EXPR_WFL_NODE (id);
9310   tree decl;
9311
9312   /* 6.5.5.1: Simple expression names */
9313   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9314     {
9315       /* 15.13.1: NAME can appear within the scope of a local variable
9316          declaration */
9317       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9318         return decl;
9319
9320       /* 15.13.1: NAME can appear within a class declaration */
9321       else
9322         {
9323           decl = lookup_field_wrapper (current_class, name);
9324           if (decl)
9325             {
9326               tree access = NULL_TREE;
9327               int fs = FIELD_STATIC (decl);
9328
9329               /* If we're accessing an outer scope local alias, make
9330                  sure we change the name of the field we're going to
9331                  build access to. */
9332               if (FIELD_LOCAL_ALIAS_USED (decl))
9333                 name = DECL_NAME (decl);
9334
9335               check_deprecation (id, decl);
9336
9337               /* Instance variable (8.3.1.1) can't appear within
9338                  static method, static initializer or initializer for
9339                  a static variable. */
9340               if (!fs && METHOD_STATIC (current_function_decl))
9341                 {
9342                   static_ref_err (id, name, current_class);
9343                   return error_mark_node;
9344                 }
9345               /* Instance variables can't appear as an argument of
9346                  an explicit constructor invocation */
9347               if (!fs && ctxp->explicit_constructor_p
9348                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9349                 {
9350                   parse_error_context
9351                     (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9352                   return error_mark_node;
9353                 }
9354
9355               /* If we're processing an inner class and we're trying
9356                  to access a field belonging to an outer class, build
9357                  the access to the field */
9358               if (!fs && outer_field_access_p (current_class, decl))
9359                 {
9360                   if (CLASS_STATIC (TYPE_NAME (current_class)))
9361                     {
9362                       static_ref_err (id, DECL_NAME (decl), current_class);
9363                       return error_mark_node;
9364                     }
9365                   access = build_outer_field_access (id, decl);
9366                   if (orig)
9367                     *orig = access;
9368                   return access;
9369                 }
9370
9371               /* Otherwise build what it takes to access the field */
9372               access = build_field_ref ((fs ? NULL_TREE : current_this),
9373                                         DECL_CONTEXT (decl), name);
9374               if (fs)
9375                 access = maybe_build_class_init_for_field (decl, access);
9376               /* We may be asked to save the real field access node */
9377               if (orig)
9378                 *orig = access;
9379               /* Last check: can we access the field? */
9380               if (not_accessible_p (current_class, decl, NULL_TREE, 0))
9381                 {
9382                   not_accessible_field_error (id, decl);
9383                   return error_mark_node;
9384                 }
9385               /* And we return what we got */
9386               return access;
9387             }
9388           /* Fall down to error report on undefined variable */
9389         }
9390     }
9391   /* 6.5.5.2 Qualified Expression Names */
9392   else
9393     {
9394       if (orig)
9395         *orig = NULL_TREE;
9396       qualify_ambiguous_name (id);
9397       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9398       /* 15.10.2: Accessing Superclass Members using super */
9399       return resolve_field_access (id, orig, NULL);
9400     }
9401
9402   /* We've got an error here */
9403   if (INNER_CLASS_TYPE_P (current_class))
9404     parse_error_context (id,
9405                          "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9406                          IDENTIFIER_POINTER (name),
9407                          IDENTIFIER_POINTER (DECL_NAME
9408                                              (TYPE_NAME (current_class))));
9409   else
9410     parse_error_context (id, "Undefined variable `%s'",
9411                          IDENTIFIER_POINTER (name));
9412
9413   return error_mark_node;
9414 }
9415
9416 static void
9417 static_ref_err (tree wfl, tree field_id, tree class_type)
9418 {
9419   parse_error_context
9420     (wfl,
9421      "Can't make a static reference to nonstatic variable `%s' in class `%s'",
9422      IDENTIFIER_POINTER (field_id),
9423      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9424 }
9425
9426 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9427    We return something suitable to generate the field access. We also
9428    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9429    recipient's address can be null. */
9430
9431 static tree
9432 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9433 {
9434   int is_static = 0;
9435   tree field_ref;
9436   tree decl = NULL_TREE, where_found, type_found;
9437
9438   if (resolve_qualified_expression_name (qual_wfl, &decl,
9439                                          &where_found, &type_found))
9440     return error_mark_node;
9441
9442   /* Resolve the LENGTH field of an array here */
9443   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9444       && type_found && TYPE_ARRAY_P (type_found)
9445       && ! flag_emit_class_files && ! flag_emit_xref)
9446     {
9447       tree length = build_java_array_length_access (where_found);
9448       field_ref = length;
9449
9450       /* In case we're dealing with a static array, we need to
9451          initialize its class before the array length can be fetched.
9452          It's also a good time to create a DECL_RTL for the field if
9453          none already exists, otherwise if the field was declared in a
9454          class found in an external file and hasn't been (and won't
9455          be) accessed for its value, none will be created. */
9456       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9457         {
9458           build_static_field_ref (where_found);
9459           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9460         }
9461     }
9462   /* We might have been trying to resolve field.method(). In which
9463      case, the resolution is over and decl is the answer */
9464   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9465     field_ref = decl;
9466   else if (JDECL_P (decl))
9467     {
9468       if (!type_found)
9469         type_found = DECL_CONTEXT (decl);
9470       is_static = FIELD_STATIC (decl);
9471       field_ref = build_field_ref ((is_static && !flag_emit_xref?
9472                                     NULL_TREE : where_found),
9473                                    type_found, DECL_NAME (decl));
9474       if (field_ref == error_mark_node)
9475         return error_mark_node;
9476       if (is_static)
9477         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9478
9479       /* If we're looking at a static field, we may need to generate a
9480          class initialization for it.  This can happen when the access
9481          looks like `field.ref', where `field' is a static field in an
9482          interface we implement.  */
9483       if (!flag_emit_class_files
9484           && !flag_emit_xref
9485           && TREE_CODE (where_found) == VAR_DECL
9486           && FIELD_STATIC (where_found))
9487         {
9488           build_static_field_ref (where_found);
9489           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9490         }
9491     }
9492   else
9493     field_ref = decl;
9494
9495   if (field_decl)
9496     *field_decl = decl;
9497   if (field_type)
9498     *field_type = (QUAL_DECL_TYPE (decl) ?
9499                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9500   return field_ref;
9501 }
9502
9503 /* If NODE is an access to f static field, strip out the class
9504    initialization part and return the field decl, otherwise, return
9505    NODE. */
9506
9507 static tree
9508 strip_out_static_field_access_decl (tree node)
9509 {
9510   if (TREE_CODE (node) == COMPOUND_EXPR)
9511     {
9512       tree op1 = TREE_OPERAND (node, 1);
9513       if (TREE_CODE (op1) == COMPOUND_EXPR)
9514          {
9515            tree call = TREE_OPERAND (op1, 0);
9516            if (TREE_CODE (call) == CALL_EXPR
9517                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9518                && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9519                == soft_initclass_node)
9520              return TREE_OPERAND (op1, 1);
9521          }
9522       else if (JDECL_P (op1))
9523         return op1;
9524     }
9525   return node;
9526 }
9527
9528 /* 6.5.5.2: Qualified Expression Names */
9529
9530 static int
9531 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9532                                    tree *where_found, tree *type_found)
9533 {
9534   int from_type = 0;            /* Field search initiated from a type */
9535   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9536   int previous_call_static = 0;
9537   int is_static;
9538   tree decl = NULL_TREE, type = NULL_TREE, q;
9539   /* For certain for of inner class instantiation */
9540   tree saved_current, saved_this;
9541 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9542   { current_class = saved_current; current_this = saved_this;}
9543
9544   *type_found = *where_found = NULL_TREE;
9545
9546   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9547     {
9548       tree qual_wfl = QUAL_WFL (q);
9549       tree ret_decl;            /* for EH checking */
9550       int location;             /* for EH checking */
9551
9552       /* 15.10.1 Field Access Using a Primary */
9553       switch (TREE_CODE (qual_wfl))
9554         {
9555         case CALL_EXPR:
9556         case NEW_CLASS_EXPR:
9557           /* If the access to the function call is a non static field,
9558              build the code to access it. */
9559           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9560             {
9561               decl = maybe_access_field (decl, *where_found,
9562                                          DECL_CONTEXT (decl));
9563               if (decl == error_mark_node)
9564                 return 1;
9565             }
9566
9567           /* And code for the function call */
9568           if (complete_function_arguments (qual_wfl))
9569             return 1;
9570
9571           /* We might have to setup a new current class and a new this
9572              for the search of an inner class, relative to the type of
9573              a expression resolved as `decl'. The current values are
9574              saved and restored shortly after */
9575           saved_current = current_class;
9576           saved_this = current_this;
9577           if (decl
9578               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9579                   || from_qualified_this))
9580             {
9581               /* If we still have `from_qualified_this', we have the form
9582                  <T>.this.f() and we need to build <T>.this */
9583               if (from_qualified_this)
9584                 {
9585                   decl = build_access_to_thisn (current_class, type, 0);
9586                   decl = java_complete_tree (decl);
9587                   type = TREE_TYPE (TREE_TYPE (decl));
9588                 }
9589               current_class = type;
9590               current_this = decl;
9591               from_qualified_this = 0;
9592             }
9593
9594           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9595             CALL_USING_SUPER (qual_wfl) = 1;
9596           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9597                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9598           *where_found = patch_method_invocation (qual_wfl, decl, type,
9599                                                   from_super,
9600                                                   &is_static, &ret_decl);
9601           from_super = 0;
9602           if (*where_found == error_mark_node)
9603             {
9604               RESTORE_THIS_AND_CURRENT_CLASS;
9605               return 1;
9606             }
9607           *type_found = type = QUAL_DECL_TYPE (*where_found);
9608
9609           *where_found = force_evaluation_order (*where_found);
9610
9611           /* If we're creating an inner class instance, check for that
9612              an enclosing instance is in scope */
9613           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9614               && INNER_ENCLOSING_SCOPE_CHECK (type))
9615             {
9616               parse_error_context
9617                 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
9618                  lang_printable_name (type, 0),
9619                  (!current_this ? "" :
9620                   "; an explicit one must be provided when creating this inner class"));
9621               RESTORE_THIS_AND_CURRENT_CLASS;
9622               return 1;
9623             }
9624
9625           /* In case we had to change then to resolve a inner class
9626              instantiation using a primary qualified by a `new' */
9627           RESTORE_THIS_AND_CURRENT_CLASS;
9628
9629           if (location)
9630             {
9631               tree arguments = NULL_TREE;
9632               if (TREE_CODE (qual_wfl) == CALL_EXPR
9633                   && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9634                 arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9635               check_thrown_exceptions (location, ret_decl, arguments);
9636             }
9637
9638           /* If the previous call was static and this one is too,
9639              build a compound expression to hold the two (because in
9640              that case, previous function calls aren't transported as
9641              forcoming function's argument. */
9642           if (previous_call_static && is_static)
9643             {
9644               decl = build (COMPOUND_EXPR, TREE_TYPE (*where_found),
9645                             decl, *where_found);
9646               TREE_SIDE_EFFECTS (decl) = 1;
9647             }
9648           else
9649             {
9650               previous_call_static = is_static;
9651               decl = *where_found;
9652             }
9653           from_type = 0;
9654           continue;
9655
9656         case NEW_ARRAY_EXPR:
9657         case NEW_ANONYMOUS_ARRAY_EXPR:
9658           *where_found = decl = java_complete_tree (qual_wfl);
9659           if (decl == error_mark_node)
9660             return 1;
9661           *type_found = type = QUAL_DECL_TYPE (decl);
9662           continue;
9663
9664         case CONVERT_EXPR:
9665           *where_found = decl = java_complete_tree (qual_wfl);
9666           if (decl == error_mark_node)
9667             return 1;
9668           *type_found = type = QUAL_DECL_TYPE (decl);
9669           from_cast = 1;
9670           continue;
9671
9672         case CONDITIONAL_EXPR:
9673         case STRING_CST:
9674         case MODIFY_EXPR:
9675           *where_found = decl = java_complete_tree (qual_wfl);
9676           if (decl == error_mark_node)
9677             return 1;
9678           *type_found = type = QUAL_DECL_TYPE (decl);
9679           continue;
9680
9681         case ARRAY_REF:
9682           /* If the access to the function call is a non static field,
9683              build the code to access it. */
9684           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9685             {
9686               decl = maybe_access_field (decl, *where_found, type);
9687               if (decl == error_mark_node)
9688                 return 1;
9689             }
9690           /* And code for the array reference expression */
9691           decl = java_complete_tree (qual_wfl);
9692           if (decl == error_mark_node)
9693             return 1;
9694           type = QUAL_DECL_TYPE (decl);
9695           continue;
9696
9697         case PLUS_EXPR:
9698           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9699             return 1;
9700           if ((type = patch_string (decl)))
9701             decl = type;
9702           *where_found = QUAL_RESOLUTION (q) = decl;
9703           *type_found = type = TREE_TYPE (decl);
9704           break;
9705
9706         case CLASS_LITERAL:
9707           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9708             return 1;
9709           *where_found = QUAL_RESOLUTION (q) = decl;
9710           *type_found = type = TREE_TYPE (decl);
9711           break;
9712
9713         default:
9714           /* Fix for -Wall Just go to the next statement. Don't
9715              continue */
9716           break;
9717         }
9718
9719       /* If we fall here, we weren't processing a (static) function call. */
9720       previous_call_static = 0;
9721
9722       /* It can be the keyword THIS */
9723       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9724           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9725         {
9726           if (!current_this)
9727             {
9728               parse_error_context
9729                 (wfl, "Keyword `this' used outside allowed context");
9730               return 1;
9731             }
9732           if (ctxp->explicit_constructor_p
9733               && type == current_class)
9734             {
9735               parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9736               return 1;
9737             }
9738           /* We have to generate code for intermediate access */
9739           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9740             {
9741               *where_found = decl = current_this;
9742               *type_found = type = QUAL_DECL_TYPE (decl);
9743             }
9744           /* We're trying to access the this from somewhere else. Make sure
9745              it's allowed before doing so. */
9746           else
9747             {
9748               if (!enclosing_context_p (type, current_class))
9749                 {
9750                   char *p  = xstrdup (lang_printable_name (type, 0));
9751                   parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9752                                        p, p,
9753                                        lang_printable_name (current_class, 0));
9754                   free (p);
9755                   return 1;
9756                 }
9757               from_qualified_this = 1;
9758               /* If there's nothing else after that, we need to
9759                  produce something now, otherwise, the section of the
9760                  code that needs to produce <T>.this will generate
9761                  what is necessary. */
9762               if (!TREE_CHAIN (q))
9763                 {
9764                   decl = build_access_to_thisn (current_class, type, 0);
9765                   *where_found = decl = java_complete_tree (decl);
9766                   *type_found = type = TREE_TYPE (decl);
9767                 }
9768             }
9769
9770           from_type = 0;
9771           continue;
9772         }
9773
9774       /* 15.10.2 Accessing Superclass Members using SUPER */
9775       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9776           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9777         {
9778           tree node;
9779           /* Check on the restricted use of SUPER */
9780           if (METHOD_STATIC (current_function_decl)
9781               || current_class == object_type_node)
9782             {
9783               parse_error_context
9784                 (wfl, "Keyword `super' used outside allowed context");
9785               return 1;
9786             }
9787           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9788           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9789                              CLASSTYPE_SUPER (current_class),
9790                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9791           *where_found = decl = java_complete_tree (node);
9792           if (decl == error_mark_node)
9793             return 1;
9794           *type_found = type = QUAL_DECL_TYPE (decl);
9795           from_super = from_type = 1;
9796           continue;
9797         }
9798
9799       /* 15.13.1: Can't search for field name in packages, so we
9800          assume a variable/class name was meant. */
9801       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9802         {
9803           tree name;
9804           if ((decl = resolve_package (wfl, &q, &name)))
9805             {
9806               tree list;
9807               *where_found = decl;
9808
9809               check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
9810
9811               /* We want to be absolutely sure that the class is laid
9812                  out. We're going to search something inside it. */
9813               *type_found = type = TREE_TYPE (decl);
9814               layout_class (type);
9815               from_type = 1;
9816
9817               /* Fix them all the way down, if any are left. */
9818               if (q)
9819                 {
9820                   list = TREE_CHAIN (q);
9821                   while (list)
9822                     {
9823                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9824                       list = TREE_CHAIN (list);
9825                     }
9826                 }
9827             }
9828           else
9829             {
9830               if (from_super || from_cast)
9831                 parse_error_context
9832                   ((from_cast ? qual_wfl : wfl),
9833                    "No variable `%s' defined in class `%s'",
9834                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9835                    lang_printable_name (type, 0));
9836               else
9837                 parse_error_context
9838                   (qual_wfl, "Undefined variable or class name: `%s'",
9839                    IDENTIFIER_POINTER (name));
9840               return 1;
9841             }
9842         }
9843
9844       /* We have a type name. It's been already resolved when the
9845          expression was qualified. */
9846       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9847         {
9848           decl = QUAL_RESOLUTION (q);
9849
9850           /* Sneak preview. If next we see a `new', we're facing a
9851              qualification which resulted in a type being selected
9852              instead of a field.  Report the error.  */
9853           if(TREE_CHAIN (q)
9854              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9855             {
9856               parse_error_context (qual_wfl, "Undefined variable `%s'",
9857                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9858               return 1;
9859             }
9860
9861           check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
9862
9863           check_deprecation (qual_wfl, decl);
9864
9865           type = TREE_TYPE (decl);
9866           from_type = 1;
9867         }
9868       /* We resolve an expression name */
9869       else
9870         {
9871           tree field_decl = NULL_TREE;
9872
9873           /* If there exists an early resolution, use it. That occurs
9874              only once and we know that there are more things to
9875              come. Don't do that when processing something after SUPER
9876              (we need more thing to be put in place below */
9877           if (!from_super && QUAL_RESOLUTION (q))
9878             {
9879               decl = QUAL_RESOLUTION (q);
9880               if (!type)
9881                 {
9882                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9883                     {
9884                       if (current_this)
9885                         *where_found = current_this;
9886                       else
9887                         {
9888                           static_ref_err (qual_wfl, DECL_NAME (decl),
9889                                           current_class);
9890                           return 1;
9891                         }
9892                       if (outer_field_access_p (current_class, decl))
9893                         decl = build_outer_field_access (qual_wfl, decl);
9894                     }
9895                   else
9896                     {
9897                       *where_found = TREE_TYPE (decl);
9898                       if (TREE_CODE (*where_found) == POINTER_TYPE)
9899                         *where_found = TREE_TYPE (*where_found);
9900                     }
9901                 }
9902             }
9903
9904           /* Report and error if we're using a numerical literal as a
9905              qualifier. It can only be an INTEGER_CST. */
9906           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9907             {
9908               parse_error_context
9909                 (wfl, "Can't use type `%s' as a qualifier",
9910                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
9911               return 1;
9912             }
9913
9914           /* We have to search for a field, knowing the type of its
9915              container. The flag FROM_TYPE indicates that we resolved
9916              the last member of the expression as a type name, which
9917              means that for the resolution of this field, we'll look
9918              for other errors than if it was resolved as a member of
9919              an other field. */
9920           else
9921             {
9922               int is_static;
9923               tree field_decl_type; /* For layout */
9924
9925               if (!from_type && !JREFERENCE_TYPE_P (type))
9926                 {
9927                   parse_error_context
9928                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9929                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9930                      lang_printable_name (type, 0),
9931                      IDENTIFIER_POINTER (DECL_NAME (decl)));
9932                   return 1;
9933                 }
9934
9935               field_decl = lookup_field_wrapper (type,
9936                                                  EXPR_WFL_NODE (qual_wfl));
9937
9938               /* Maybe what we're trying to access to is an inner
9939                  class, only if decl is a TYPE_DECL. */
9940               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9941                 {
9942                   tree ptr, inner_decl;
9943
9944                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9945                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9946                   if (inner_decl)
9947                     {
9948                       check_inner_class_access (inner_decl, decl, qual_wfl);
9949                       type = TREE_TYPE (inner_decl);
9950                       decl = inner_decl;
9951                       from_type = 1;
9952                       continue;
9953                     }
9954                 }
9955
9956               if (field_decl == NULL_TREE)
9957                 {
9958                   parse_error_context
9959                     (qual_wfl, "No variable `%s' defined in type `%s'",
9960                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9961                      GET_TYPE_NAME (type));
9962                   return 1;
9963                 }
9964               if (field_decl == error_mark_node)
9965                 return 1;
9966
9967               /* Layout the type of field_decl, since we may need
9968                  it. Don't do primitive types or loaded classes. The
9969                  situation of non primitive arrays may not handled
9970                  properly here. FIXME */
9971               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9972                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9973               else
9974                 field_decl_type = TREE_TYPE (field_decl);
9975               if (!JPRIMITIVE_TYPE_P (field_decl_type)
9976                   && !CLASS_LOADED_P (field_decl_type)
9977                   && !TYPE_ARRAY_P (field_decl_type))
9978                 resolve_and_layout (field_decl_type, NULL_TREE);
9979
9980               /* Check on accessibility here */
9981               if (not_accessible_p (current_class, field_decl,
9982                                     DECL_CONTEXT (field_decl), from_super))
9983                 return not_accessible_field_error (qual_wfl,field_decl);
9984               check_deprecation (qual_wfl, field_decl);
9985
9986               /* There are things to check when fields are accessed
9987                  from type. There are no restrictions on a static
9988                  declaration of the field when it is accessed from an
9989                  interface */
9990               is_static = FIELD_STATIC (field_decl);
9991               if (!from_super && from_type
9992                   && !TYPE_INTERFACE_P (type)
9993                   && !is_static
9994                   && (current_function_decl
9995                       && METHOD_STATIC (current_function_decl)))
9996                 {
9997                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
9998                   return 1;
9999                 }
10000               from_cast = from_super = 0;
10001
10002               /* It's an access from a type but it isn't static, we
10003                  make it relative to `this'. */
10004               if (!is_static && from_type)
10005                 decl = current_this;
10006
10007               /* If we need to generate something to get a proper
10008                  handle on what this field is accessed from, do it
10009                  now. */
10010               if (!is_static)
10011                 {
10012                   decl = maybe_access_field (decl, *where_found, *type_found);
10013                   if (decl == error_mark_node)
10014                     return 1;
10015                 }
10016
10017               /* We want to keep the location were found it, and the type
10018                  we found. */
10019               *where_found = decl;
10020               *type_found = type;
10021
10022               /* Generate the correct expression for field access from
10023                  qualified this */
10024               if (from_qualified_this)
10025                 {
10026                   field_decl = build_outer_field_access (qual_wfl, field_decl);
10027                   from_qualified_this = 0;
10028                 }
10029
10030               /* This is the decl found and eventually the next one to
10031                  search from */
10032               decl = field_decl;
10033             }
10034           from_type = 0;
10035           type = QUAL_DECL_TYPE (decl);
10036
10037           /* Sneak preview. If decl is qualified by a `new', report
10038              the error here to be accurate on the peculiar construct */
10039           if (TREE_CHAIN (q)
10040               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10041               && !JREFERENCE_TYPE_P (type))
10042             {
10043               parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
10044                                    lang_printable_name (type, 0));
10045               return 1;
10046             }
10047         }
10048       /* `q' might have changed due to a after package resolution
10049          re-qualification */
10050       if (!q)
10051         break;
10052     }
10053   *found_decl = decl;
10054   return 0;
10055 }
10056
10057 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10058    can't be accessed from REFERENCE (a record type). If MEMBER
10059    features a protected access, we then use WHERE which, if non null,
10060    holds the type of MEMBER's access that is checked against
10061    6.6.2.1. This function should be used when decl is a field or a
10062    method.  */
10063
10064 static int
10065 not_accessible_p (tree reference, tree member, tree where, int from_super)
10066 {
10067   int access_flag = get_access_flags_from_decl (member);
10068
10069   /* Inner classes are processed by check_inner_class_access */
10070   if (INNER_CLASS_TYPE_P (reference))
10071     return 0;
10072
10073   /* Access always granted for members declared public */
10074   if (access_flag & ACC_PUBLIC)
10075     return 0;
10076
10077   /* Check access on protected members */
10078   if (access_flag & ACC_PROTECTED)
10079     {
10080       /* Access granted if it occurs from within the package
10081          containing the class in which the protected member is
10082          declared */
10083       if (class_in_current_package (DECL_CONTEXT (member)))
10084         return 0;
10085
10086       /* If accessed with the form `super.member', then access is granted */
10087       if (from_super)
10088         return 0;
10089
10090       /* If where is active, access was made through a
10091          qualifier. Access is granted if the type of the qualifier is
10092          or is a sublass of the type the access made from (6.6.2.1.)  */
10093       if (where && !inherits_from_p (reference, where))
10094         return 1;
10095
10096       /* Otherwise, access is granted if occurring from the class where
10097          member is declared or a subclass of it. Find the right
10098          context to perform the check */
10099       if (PURE_INNER_CLASS_TYPE_P (reference))
10100         {
10101           while (INNER_CLASS_TYPE_P (reference))
10102             {
10103               if (inherits_from_p (reference, DECL_CONTEXT (member)))
10104                 return 0;
10105               reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10106             }
10107         }
10108       if (inherits_from_p (reference, DECL_CONTEXT (member)))
10109         return 0;
10110       return 1;
10111     }
10112
10113   /* Check access on private members. Access is granted only if it
10114      occurs from within the class in which it is declared -- that does
10115      it for innerclasses too. */
10116   if (access_flag & ACC_PRIVATE)
10117     {
10118       if (reference == DECL_CONTEXT (member))
10119         return 0;
10120       if (enclosing_context_p (reference, DECL_CONTEXT (member)))
10121         return 0;
10122       return 1;
10123     }
10124
10125   /* Default access is permitted only when occurring from within the
10126      package in which the context (MEMBER) is declared.  */
10127   return !class_in_current_package (DECL_CONTEXT (member));
10128 }
10129
10130 /* Test deprecated decl access.  */
10131 static void
10132 check_deprecation (tree wfl, tree decl)
10133 {
10134   const char *file;
10135   tree elt;
10136
10137   if (! flag_deprecated)
10138     return;
10139
10140   /* We want to look at the element type of arrays here, so we strip
10141      all surrounding array types.  */
10142   if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10143     {
10144       elt = TREE_TYPE (decl);
10145       while (TYPE_ARRAY_P (elt))
10146         elt = TYPE_ARRAY_ELEMENT (elt);
10147       /* We'll end up with a pointer type, so we use TREE_TYPE to go
10148          to the record.  */
10149       decl = TYPE_NAME (TREE_TYPE (elt));
10150     }
10151   file = DECL_SOURCE_FILE (decl);
10152
10153   /* Complain if the field is deprecated and the file it was defined
10154      in isn't compiled at the same time the file which contains its
10155      use is */
10156   if (DECL_DEPRECATED (decl)
10157       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10158     {
10159       const char *the;
10160       switch (TREE_CODE (decl))
10161         {
10162         case FUNCTION_DECL:
10163           the = "method";
10164           break;
10165         case FIELD_DECL:
10166         case VAR_DECL:
10167           the = "field";
10168           break;
10169         case TYPE_DECL:
10170           parse_warning_context (wfl, "The class `%s' has been deprecated",
10171                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10172           return;
10173         default:
10174           abort ();
10175         }
10176       /* Don't issue a message if the context as been deprecated as a
10177          whole. */
10178       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10179         parse_warning_context
10180           (wfl, "The %s `%s' in class `%s' has been deprecated",
10181            the, lang_printable_name (decl, 0),
10182            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10183     }
10184 }
10185
10186 /* Returns 1 if class was declared in the current package, 0 otherwise */
10187
10188 static GTY(()) tree cicp_cache;
10189 static int
10190 class_in_current_package (tree class)
10191 {
10192   int qualified_flag;
10193   tree left;
10194
10195   if (cicp_cache == class)
10196     return 1;
10197
10198   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10199
10200   /* If the current package is empty and the name of CLASS is
10201      qualified, class isn't in the current package.  If there is a
10202      current package and the name of the CLASS is not qualified, class
10203      isn't in the current package */
10204   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10205     return 0;
10206
10207   /* If there is not package and the name of CLASS isn't qualified,
10208      they belong to the same unnamed package */
10209   if (!ctxp->package && !qualified_flag)
10210     return 1;
10211
10212   /* Compare the left part of the name of CLASS with the package name */
10213   breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10214   if (ctxp->package == left)
10215     {
10216       cicp_cache = class;
10217       return 1;
10218     }
10219   return 0;
10220 }
10221
10222 /* This function may generate code to access DECL from WHERE. This is
10223    done only if certain conditions meet.  */
10224
10225 static tree
10226 maybe_access_field (tree decl, tree where, tree type)
10227 {
10228   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10229       && !FIELD_STATIC (decl))
10230     decl = build_field_ref (where ? where : current_this,
10231                             (type ? type : DECL_CONTEXT (decl)),
10232                             DECL_NAME (decl));
10233   return decl;
10234 }
10235
10236 /* Build a method invocation, by patching PATCH. If non NULL
10237    and according to the situation, PRIMARY and WHERE may be
10238    used. IS_STATIC is set to 1 if the invoked function is static. */
10239
10240 static tree
10241 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10242                          int *is_static, tree *ret_decl)
10243 {
10244   tree wfl = TREE_OPERAND (patch, 0);
10245   tree args = TREE_OPERAND (patch, 1);
10246   tree name = EXPR_WFL_NODE (wfl);
10247   tree list;
10248   int is_static_flag = 0;
10249   int is_super_init = 0;
10250   tree this_arg = NULL_TREE;
10251   int is_array_clone_call = 0;
10252
10253   /* Should be overridden if everything goes well. Otherwise, if
10254      something fails, it should keep this value. It stop the
10255      evaluation of a bogus assignment. See java_complete_tree,
10256      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10257      evaluating an assignment */
10258   TREE_TYPE (patch) = error_mark_node;
10259
10260   /* Since lookup functions are messing with line numbers, save the
10261      context now.  */
10262   java_parser_context_save_global ();
10263
10264   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10265
10266   /* Resolution of qualified name, excluding constructors */
10267   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10268     {
10269       tree identifier, identifier_wfl, type, resolved;
10270       /* Extract the last IDENTIFIER of the qualified
10271          expression. This is a wfl and we will use it's location
10272          data during error report. */
10273       identifier_wfl = cut_identifier_in_qualified (wfl);
10274       identifier = EXPR_WFL_NODE (identifier_wfl);
10275
10276       /* Given the context, IDENTIFIER is syntactically qualified
10277          as a MethodName. We need to qualify what's before */
10278       qualify_ambiguous_name (wfl);
10279       resolved = resolve_field_access (wfl, NULL, NULL);
10280
10281       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10282          && FIELD_FINAL (resolved)
10283          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10284          && !flag_emit_class_files && !flag_emit_xref)
10285        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10286
10287       if (resolved == error_mark_node)
10288         PATCH_METHOD_RETURN_ERROR ();
10289
10290       type = GET_SKIP_TYPE (resolved);
10291       resolve_and_layout (type, NULL_TREE);
10292
10293       if (JPRIMITIVE_TYPE_P (type))
10294         {
10295           parse_error_context
10296             (identifier_wfl,
10297              "Can't invoke a method on primitive type `%s'",
10298              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10299           PATCH_METHOD_RETURN_ERROR ();
10300         }
10301
10302       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10303       args = nreverse (args);
10304
10305       /* We're resolving a call from a type */
10306       if (TREE_CODE (resolved) == TYPE_DECL)
10307         {
10308           if (CLASS_INTERFACE (resolved))
10309             {
10310               parse_error_context
10311                 (identifier_wfl,
10312                 "Can't make static reference to method `%s' in interface `%s'",
10313                  IDENTIFIER_POINTER (identifier),
10314                  IDENTIFIER_POINTER (name));
10315               PATCH_METHOD_RETURN_ERROR ();
10316             }
10317           if (list && !METHOD_STATIC (list))
10318             {
10319               char *fct_name = xstrdup (lang_printable_name (list, 0));
10320               parse_error_context
10321                 (identifier_wfl,
10322                  "Can't make static reference to method `%s %s' in class `%s'",
10323                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10324                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10325               free (fct_name);
10326               PATCH_METHOD_RETURN_ERROR ();
10327             }
10328         }
10329       else
10330         this_arg = primary = resolved;
10331
10332       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10333         is_array_clone_call = 1;
10334
10335       /* IDENTIFIER_WFL will be used to report any problem further */
10336       wfl = identifier_wfl;
10337     }
10338   /* Resolution of simple names, names generated after a primary: or
10339      constructors */
10340   else
10341     {
10342       tree class_to_search = NULL_TREE;
10343       int lc;                   /* Looking for Constructor */
10344
10345       /* We search constructor in their target class */
10346       if (CALL_CONSTRUCTOR_P (patch))
10347         {
10348           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10349             class_to_search = EXPR_WFL_NODE (wfl);
10350           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10351                    this_identifier_node)
10352             class_to_search = NULL_TREE;
10353           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10354                    super_identifier_node)
10355             {
10356               is_super_init = 1;
10357               if (CLASSTYPE_SUPER (current_class))
10358                 class_to_search =
10359                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10360               else
10361                 {
10362                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10363                   PATCH_METHOD_RETURN_ERROR ();
10364                 }
10365             }
10366
10367           /* Class to search is NULL if we're searching the current one */
10368           if (class_to_search)
10369             {
10370               class_to_search = resolve_and_layout (class_to_search, wfl);
10371
10372               if (!class_to_search)
10373                 {
10374                   parse_error_context
10375                     (wfl, "Class `%s' not found in type declaration",
10376                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10377                   PATCH_METHOD_RETURN_ERROR ();
10378                 }
10379
10380               /* Can't instantiate an abstract class, but we can
10381                  invoke it's constructor. It's use within the `new'
10382                  context is denied here. */
10383               if (CLASS_ABSTRACT (class_to_search)
10384                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10385                 {
10386                   parse_error_context
10387                     (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10388                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10389                   PATCH_METHOD_RETURN_ERROR ();
10390                 }
10391
10392               class_to_search = TREE_TYPE (class_to_search);
10393             }
10394           else
10395             class_to_search = current_class;
10396           lc = 1;
10397         }
10398       /* This is a regular search in the local class, unless an
10399          alternate class is specified. */
10400       else
10401         {
10402           if (where != NULL_TREE)
10403             class_to_search = where;
10404           else if (QUALIFIED_P (name))
10405             class_to_search = current_class;
10406           else
10407             {
10408               class_to_search = current_class;
10409
10410               for (;;)
10411                 {
10412                   if (has_method (class_to_search, name))
10413                     break;
10414                   if (! INNER_CLASS_TYPE_P (class_to_search))
10415                     {
10416                       parse_error_context (wfl,
10417                                            "No method named `%s' in scope",
10418                                            IDENTIFIER_POINTER (name));
10419                       PATCH_METHOD_RETURN_ERROR ();
10420                     }
10421                   class_to_search
10422                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10423                 }
10424             }
10425           lc = 0;
10426         }
10427
10428       /* NAME is a simple identifier or comes from a primary. Search
10429          in the class whose declaration contain the method being
10430          invoked. */
10431       resolve_and_layout (class_to_search, NULL_TREE);
10432
10433       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10434       /* Don't continue if no method were found, as the next statement
10435          can't be executed then. */
10436       if (!list)
10437         PATCH_METHOD_RETURN_ERROR ();
10438
10439       if (TYPE_ARRAY_P (class_to_search)
10440           && DECL_NAME (list) == get_identifier ("clone"))
10441         is_array_clone_call = 1;
10442
10443       /* Check for static reference if non static methods */
10444       if (check_for_static_method_reference (wfl, patch, list,
10445                                              class_to_search, primary))
10446         PATCH_METHOD_RETURN_ERROR ();
10447
10448       /* Check for inner classes creation from illegal contexts */
10449       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10450                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10451           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10452           && !DECL_INIT_P (current_function_decl))
10453         {
10454           parse_error_context
10455             (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10456              lang_printable_name (class_to_search, 0),
10457              (!current_this ? "" :
10458               "; an explicit one must be provided when creating this inner class"));
10459           PATCH_METHOD_RETURN_ERROR ();
10460         }
10461
10462       /* Non static methods are called with the current object extra
10463          argument. If patch a `new TYPE()', the argument is the value
10464          returned by the object allocator. If method is resolved as a
10465          primary, use the primary otherwise use the current THIS. */
10466       args = nreverse (args);
10467       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10468         {
10469           this_arg = primary ? primary : current_this;
10470
10471           /* If we're using an access method, things are different.
10472              There are two family of cases:
10473
10474              1) We're not generating bytecodes:
10475
10476              - LIST is non static. It's invocation is transformed from
10477                x(a1,...,an) into this$<n>.x(a1,....an).
10478              - LIST is static. It's invocation is transformed from
10479                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10480
10481              2) We're generating bytecodes:
10482
10483              - LIST is non static. It's invocation is transformed from
10484                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10485              - LIST is static. It's invocation is transformed from
10486                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10487
10488              Of course, this$<n> can be arbitrarily complex, ranging from
10489              this$0 (the immediate outer context) to
10490              access$0(access$0(...(this$0))).
10491
10492              maybe_use_access_method returns a nonzero value if the
10493              this_arg has to be moved into the (then generated) stub
10494              argument list. In the meantime, the selected function
10495              might have be replaced by a generated stub. */
10496           if (!primary &&
10497               maybe_use_access_method (is_super_init, &list, &this_arg))
10498             {
10499               args = tree_cons (NULL_TREE, this_arg, args);
10500               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10501             }
10502         }
10503     }
10504
10505   /* Merge point of all resolution schemes. If we have nothing, this
10506      is an error, already signaled */
10507   if (!list)
10508     PATCH_METHOD_RETURN_ERROR ();
10509
10510   /* Check accessibility, position the is_static flag, build and
10511      return the call */
10512   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10513                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10514                          NULL_TREE), from_super)
10515       /* Calls to clone() on array types are permitted as a special-case. */
10516       && !is_array_clone_call)
10517     {
10518       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10519       const char *const access =
10520         accessibility_string (get_access_flags_from_decl (list));
10521       const char *const klass =
10522         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10523       const char *const refklass =
10524         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10525       const char *const what = (DECL_CONSTRUCTOR_P (list)
10526                                 ? "constructor" : "method");
10527       /* FIXME: WFL yields the wrong message here but I don't know
10528          what else to use.  */
10529       parse_error_context (wfl,
10530                            "Can't access %s %s `%s.%s' from `%s'",
10531                            access, what, klass, fct_name, refklass);
10532       PATCH_METHOD_RETURN_ERROR ();
10533     }
10534
10535   /* Deprecation check: check whether the method being invoked or the
10536      instance-being-created's type are deprecated.  */
10537   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10538     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10539   check_deprecation (wfl, list);
10540
10541   /* If invoking a innerclass constructor, there are hidden parameters
10542      to pass */
10543   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10544       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10545     {
10546       /* And make sure we add the accessed local variables to be saved
10547          in field aliases. */
10548       args = build_alias_initializer_parameter_list
10549         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10550
10551       /* Secretly pass the current_this/primary as a second argument */
10552       if (primary || current_this)
10553         {
10554           tree extra_arg;
10555           tree this_type = (current_this ?
10556                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10557           /* Method's (list) enclosing context */
10558           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10559           /* If we have a primary, use it. */
10560           if (primary)
10561             extra_arg = primary;
10562           /* The current `this' is an inner class but isn't a direct
10563              enclosing context for the inner class we're trying to
10564              create. Build an access to the proper enclosing context
10565              and use it. */
10566           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10567                    && this_type != TREE_TYPE (mec))
10568             {
10569
10570               extra_arg = build_access_to_thisn (current_class,
10571                                                  TREE_TYPE (mec), 0);
10572               extra_arg = java_complete_tree (extra_arg);
10573             }
10574           /* Otherwise, just use the current `this' as an enclosing
10575              context. */
10576           else
10577             extra_arg = current_this;
10578           args = tree_cons (NULL_TREE, extra_arg, args);
10579         }
10580       else
10581         args = tree_cons (NULL_TREE, integer_zero_node, args);
10582     }
10583
10584   /* This handles the situation where a constructor invocation needs
10585      to have an enclosing context passed as a second parameter (the
10586      constructor is one of an inner class). */
10587   if ((is_super_init ||
10588        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10589       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10590     {
10591       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10592       tree extra_arg =
10593         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10594       extra_arg = java_complete_tree (extra_arg);
10595       args = tree_cons (NULL_TREE, extra_arg, args);
10596     }
10597
10598   is_static_flag = METHOD_STATIC (list);
10599   if (! is_static_flag && this_arg != NULL_TREE)
10600     args = tree_cons (NULL_TREE, this_arg, args);
10601
10602   /* In the context of an explicit constructor invocation, we can't
10603      invoke any method relying on `this'. Exceptions are: we're
10604      invoking a static function, primary exists and is not the current
10605      this, we're creating a new object. */
10606   if (ctxp->explicit_constructor_p
10607       && !is_static_flag
10608       && (!primary || primary == current_this)
10609       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10610     {
10611       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10612       PATCH_METHOD_RETURN_ERROR ();
10613     }
10614   java_parser_context_restore_global ();
10615   if (is_static)
10616     *is_static = is_static_flag;
10617   /* Sometimes, we want the decl of the selected method. Such as for
10618      EH checking */
10619   if (ret_decl)
10620     *ret_decl = list;
10621   patch = patch_invoke (patch, list, args);
10622
10623   /* Now is a good time to insert the call to finit$ */
10624   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10625     {
10626       tree finit_parms, finit_call;
10627
10628       /* Prepare to pass hidden parameters to finit$, if any. */
10629       finit_parms = build_alias_initializer_parameter_list
10630         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10631
10632       finit_call =
10633         build_method_invocation (build_wfl_node (finit_identifier_node),
10634                                  finit_parms);
10635
10636       /* Generate the code used to initialize fields declared with an
10637          initialization statement and build a compound statement along
10638          with the super constructor invocation. */
10639       CAN_COMPLETE_NORMALLY (patch) = 1;
10640       patch = build (COMPOUND_EXPR, void_type_node, patch,
10641                      java_complete_tree (finit_call));
10642     }
10643   return patch;
10644 }
10645
10646 /* Check that we're not trying to do a static reference to a method in
10647    non static method. Return 1 if it's the case, 0 otherwise. */
10648
10649 static int
10650 check_for_static_method_reference (tree wfl, tree node, tree method,
10651                                    tree where, tree primary)
10652 {
10653   if (METHOD_STATIC (current_function_decl)
10654       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10655     {
10656       char *fct_name = xstrdup (lang_printable_name (method, 0));
10657       parse_error_context
10658         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10659          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10660          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10661       free (fct_name);
10662       return 1;
10663     }
10664   return 0;
10665 }
10666
10667 /* Fix the invocation of *MDECL if necessary in the case of a
10668    invocation from an inner class. *THIS_ARG might be modified
10669    appropriately and an alternative access to *MDECL might be
10670    returned.  */
10671
10672 static int
10673 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10674 {
10675   tree ctx;
10676   tree md = *mdecl, ta = *this_arg;
10677   int to_return = 0;
10678   int non_static_context = !METHOD_STATIC (md);
10679
10680   if (is_super_init
10681       || DECL_CONTEXT (md) == current_class
10682       || !PURE_INNER_CLASS_TYPE_P (current_class)
10683       || DECL_FINIT_P (md)
10684       || DECL_INSTINIT_P (md))
10685     return 0;
10686
10687   /* If we're calling a method found in an enclosing class, generate
10688      what it takes to retrieve the right this. Don't do that if we're
10689      invoking a static method. Note that if MD's type is unrelated to
10690      CURRENT_CLASS, then the current this can be used. */
10691
10692   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10693     {
10694       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10695       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10696         {
10697           ta = build_current_thisn (current_class);
10698           ta = build_wfl_node (ta);
10699         }
10700       else
10701         {
10702           tree type = ctx;
10703           while (type)
10704             {
10705               maybe_build_thisn_access_method (type);
10706               if (inherits_from_p (type, DECL_CONTEXT (md)))
10707                 {
10708                   ta = build_access_to_thisn (ctx, type, 0);
10709                   break;
10710                 }
10711               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10712                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10713             }
10714         }
10715       ta = java_complete_tree (ta);
10716     }
10717
10718   /* We might have to use an access method to get to MD. We can
10719      break the method access rule as far as we're not generating
10720      bytecode */
10721   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10722     {
10723       md = build_outer_method_access_method (md);
10724       to_return = 1;
10725     }
10726
10727   *mdecl = md;
10728   *this_arg = ta;
10729
10730   /* Returning a nonzero value indicates we were doing a non static
10731      method invocation that is now a static invocation. It will have
10732      callee displace `this' to insert it in the regular argument
10733      list. */
10734   return (non_static_context && to_return);
10735 }
10736
10737 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10738    mode.  */
10739
10740 static tree
10741 patch_invoke (tree patch, tree method, tree args)
10742 {
10743   tree dtable, func;
10744   tree original_call, t, ta;
10745   tree check = NULL_TREE;
10746
10747   /* Last step for args: convert build-in types. If we're dealing with
10748      a new TYPE() type call, the first argument to the constructor
10749      isn't found in the incoming argument list, but delivered by
10750      `new' */
10751   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10752   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10753     t = TREE_CHAIN (t);
10754   for (ta = args; t != end_params_node && ta;
10755        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10756     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10757         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10758       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10759
10760   /* Resolve unresolved returned type issues */
10761   t = TREE_TYPE (TREE_TYPE (method));
10762   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10763     resolve_and_layout (TREE_TYPE (t), NULL);
10764
10765   if (flag_emit_class_files || flag_emit_xref)
10766     func = method;
10767   else
10768     {
10769       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10770         {
10771         case INVOKE_VIRTUAL:
10772           dtable = invoke_build_dtable (0, args);
10773           func = build_invokevirtual (dtable, method);
10774           break;
10775
10776         case INVOKE_NONVIRTUAL:
10777           /* If the object for the method call is null, we throw an
10778              exception.  We don't do this if the object is the current
10779              method's `this'.  In other cases we just rely on an
10780              optimization pass to eliminate redundant checks.  */
10781           if (TREE_VALUE (args) != current_this)
10782             {
10783               /* We use a save_expr here to make sure we only evaluate
10784                  the new `self' expression once.  */
10785               tree save_arg = save_expr (TREE_VALUE (args));
10786               TREE_VALUE (args) = save_arg;
10787               check = java_check_reference (save_arg, 1);
10788             }
10789           /* Fall through.  */
10790
10791         case INVOKE_SUPER:
10792         case INVOKE_STATIC:
10793           {
10794             tree signature = build_java_signature (TREE_TYPE (method));
10795             func = build_known_method_ref (method, TREE_TYPE (method),
10796                                            DECL_CONTEXT (method),
10797                                            signature, args);
10798           }
10799           break;
10800
10801         case INVOKE_INTERFACE:
10802           dtable = invoke_build_dtable (1, args);
10803           func = build_invokeinterface (dtable, method);
10804           break;
10805
10806         default:
10807           abort ();
10808         }
10809
10810       /* Ensure self_type is initialized, (invokestatic). FIXME */
10811       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10812     }
10813
10814   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10815   TREE_OPERAND (patch, 0) = func;
10816   TREE_OPERAND (patch, 1) = args;
10817   patch = check_for_builtin (method, patch);
10818   original_call = patch;
10819
10820   /* We're processing a `new TYPE ()' form. New is called and its
10821      returned value is the first argument to the constructor. We build
10822      a COMPOUND_EXPR and use saved expression so that the overall NEW
10823      expression value is a pointer to a newly created and initialized
10824      class. */
10825   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10826     {
10827       tree class = DECL_CONTEXT (method);
10828       tree c1, saved_new, size, new;
10829       tree alloc_node;
10830
10831       if (flag_emit_class_files || flag_emit_xref)
10832         {
10833           TREE_TYPE (patch) = build_pointer_type (class);
10834           return patch;
10835         }
10836       if (!TYPE_SIZE (class))
10837         safe_layout_class (class);
10838       size = size_in_bytes (class);
10839       alloc_node =
10840         (class_has_finalize_method (class) ? alloc_object_node
10841                                            : alloc_no_finalizer_node);
10842       new = build (CALL_EXPR, promote_type (class),
10843                      build_address_of (alloc_node),
10844                      build_tree_list (NULL_TREE, build_class_ref (class)),
10845                      NULL_TREE);
10846       saved_new = save_expr (new);
10847       c1 = build_tree_list (NULL_TREE, saved_new);
10848       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10849       TREE_OPERAND (original_call, 1) = c1;
10850       TREE_SET_CODE (original_call, CALL_EXPR);
10851       patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10852     }
10853
10854   /* If CHECK is set, then we are building a check to see if the object
10855      is NULL.  */
10856   if (check != NULL_TREE)
10857     {
10858       /* We have to call force_evaluation_order now because creating a
10859          COMPOUND_EXPR wraps the arg list in a way that makes it
10860          unrecognizable by force_evaluation_order later.  Yuk.  */
10861       patch = build (COMPOUND_EXPR, TREE_TYPE (patch), check,
10862                      force_evaluation_order (patch));
10863       TREE_SIDE_EFFECTS (patch) = 1;
10864     }
10865
10866   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10867      put it as the first expression of a COMPOUND_EXPR. The second
10868      expression being an empty statement to be later patched if
10869      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10870      the VALUE is the compound) in a hashtable and return a
10871      COMPOUND_EXPR built so that the result of the evaluation of the
10872      original PATCH node is returned. */
10873   if (STATIC_CLASS_INIT_OPT_P ()
10874       && current_function_decl && METHOD_STATIC (method))
10875     {
10876       tree list;
10877       tree fndecl = current_function_decl;
10878       /* We have to call force_evaluation_order now because creating a
10879          COMPOUND_EXPR wraps the arg list in a way that makes it
10880          unrecognizable by force_evaluation_order later.  Yuk.  */
10881       tree save = force_evaluation_order (patch);
10882       tree type = TREE_TYPE (patch);
10883
10884       patch = build (COMPOUND_EXPR, type, save, build_java_empty_stmt ());
10885       list = tree_cons (method, patch,
10886                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10887
10888       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10889
10890       patch = build (COMPOUND_EXPR, type, patch, save);
10891     }
10892
10893   return patch;
10894 }
10895
10896 static int
10897 invocation_mode (tree method, int super)
10898 {
10899   int access = get_access_flags_from_decl (method);
10900
10901   if (super)
10902     return INVOKE_SUPER;
10903
10904   if (access & ACC_STATIC)
10905     return INVOKE_STATIC;
10906
10907   /* We have to look for a constructor before we handle nonvirtual
10908      calls; otherwise the constructor will look nonvirtual.  */
10909   if (DECL_CONSTRUCTOR_P (method))
10910     return INVOKE_STATIC;
10911
10912   if (access & ACC_FINAL || access & ACC_PRIVATE)
10913     return INVOKE_NONVIRTUAL;
10914
10915   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10916     return INVOKE_NONVIRTUAL;
10917
10918   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10919     return INVOKE_INTERFACE;
10920
10921   return INVOKE_VIRTUAL;
10922 }
10923
10924 /* Retrieve a refined list of matching methods. It covers the step
10925    15.11.2 (Compile-Time Step 2) */
10926
10927 static tree
10928 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
10929 {
10930   tree atl = end_params_node;           /* Arg Type List */
10931   tree method, signature, list, node;
10932   const char *candidates;               /* Used for error report */
10933   char *dup;
10934
10935   /* Fix the arguments */
10936   for (node = arg_list; node; node = TREE_CHAIN (node))
10937     {
10938       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10939       /* Non primitive type may have to be resolved */
10940       if (!JPRIMITIVE_TYPE_P (current_arg))
10941         resolve_and_layout (current_arg, NULL_TREE);
10942       /* And promoted */
10943       if (TREE_CODE (current_arg) == RECORD_TYPE)
10944         current_arg = promote_type (current_arg);
10945       atl = tree_cons (NULL_TREE, current_arg, atl);
10946     }
10947
10948   /* Presto. If we're dealing with an anonymous class and a
10949      constructor call, generate the right constructor now, since we
10950      know the arguments' types. */
10951
10952   if (lc && ANONYMOUS_CLASS_P (class))
10953     {
10954       tree saved_current_class;
10955       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10956       saved_current_class = current_class;
10957       current_class = class;
10958       fix_constructors (mdecl);
10959       current_class = saved_current_class;
10960     }
10961
10962   /* Find all candidates and then refine the list, searching for the
10963      most specific method. */
10964   list = find_applicable_accessible_methods_list (lc, class, name, atl);
10965   list = find_most_specific_methods_list (list);
10966   if (list && !TREE_CHAIN (list))
10967     return TREE_VALUE (list);
10968
10969   /* Issue an error. List candidates if any. Candidates are listed
10970      only if accessible (non accessible methods may end-up here for
10971      the sake of a better error report). */
10972   candidates = NULL;
10973   if (list)
10974     {
10975       tree current;
10976       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
10977       for (current = list; current; current = TREE_CHAIN (current))
10978         {
10979           tree cm = TREE_VALUE (current);
10980           char string [4096];
10981           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
10982             continue;
10983           sprintf
10984             (string, "  `%s' in `%s'%s",
10985              get_printable_method_name (cm),
10986              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
10987              (TREE_CHAIN (current) ? "\n" : ""));
10988           obstack_grow (&temporary_obstack, string, strlen (string));
10989         }
10990       obstack_1grow (&temporary_obstack, '\0');
10991       candidates = obstack_finish (&temporary_obstack);
10992     }
10993   /* Issue the error message */
10994   method = make_node (FUNCTION_TYPE);
10995   TYPE_ARG_TYPES (method) = atl;
10996   signature = build_java_argument_signature (method);
10997   dup = xstrdup (lang_printable_name (class, 0));
10998   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
10999                        (lc ? "constructor" : "method"),
11000                        (lc ? dup : IDENTIFIER_POINTER (name)),
11001                        IDENTIFIER_POINTER (signature), dup,
11002                        (candidates ? candidates : ""));
11003   free (dup);
11004   return NULL_TREE;
11005 }
11006
11007 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
11008    when we're looking for a constructor. */
11009
11010 static tree
11011 find_applicable_accessible_methods_list (int lc, tree class, tree name,
11012                                          tree arglist)
11013 {
11014   static htab_t searched_classes;
11015   static int search_not_done = 0;
11016   tree list = NULL_TREE, all_list = NULL_TREE;
11017
11018   /* Check the hash table to determine if this class has been searched
11019      already. */
11020   if (searched_classes)
11021     {
11022       if (htab_find (searched_classes, class) != NULL)
11023         return NULL;
11024     }
11025   else
11026     {
11027       searched_classes = htab_create (10, htab_hash_pointer,
11028                                       htab_eq_pointer, NULL);
11029     }
11030
11031   search_not_done++;
11032   *htab_find_slot (searched_classes, class, INSERT) = class;
11033
11034   if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
11035     {
11036       load_class (class, 1);
11037       safe_layout_class (class);
11038     }
11039
11040   /* Search interfaces */
11041   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11042       && CLASS_INTERFACE (TYPE_NAME (class)))
11043     {
11044       int i, n;
11045       tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11046       search_applicable_methods_list (lc, TYPE_METHODS (class),
11047                                       name, arglist, &list, &all_list);
11048       n = TREE_VEC_LENGTH (basetype_vec);
11049       for (i = 1; i < n; i++)
11050         {
11051           tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11052           tree rlist;
11053
11054           rlist = find_applicable_accessible_methods_list (lc,  t, name,
11055                                                            arglist);
11056           list = chainon (rlist, list);
11057         }
11058     }
11059   /* Search classes */
11060   else
11061     {
11062       search_applicable_methods_list (lc, TYPE_METHODS (class),
11063                                       name, arglist, &list, &all_list);
11064
11065       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11066          that we only search in class. Note that we should have found
11067          something at this point. */
11068       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11069         {
11070           lc = 1;
11071           if (!list)
11072             abort ();
11073         }
11074
11075       /* We must search all interfaces of this class */
11076       if (!lc)
11077       {
11078         tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11079         int n = TREE_VEC_LENGTH (basetype_vec), i;
11080         for (i = 1; i < n; i++)
11081           {
11082             tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11083             if (t != object_type_node)
11084               {
11085                 tree rlist
11086                   = find_applicable_accessible_methods_list (lc, t,
11087                                                              name, arglist);
11088                 list = chainon (rlist, list);
11089               }
11090           }
11091       }
11092
11093       /* Search superclass */
11094       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11095         {
11096           tree rlist;
11097           class = CLASSTYPE_SUPER (class);
11098           rlist = find_applicable_accessible_methods_list (lc, class,
11099                                                            name, arglist);
11100           list = chainon (rlist, list);
11101         }
11102     }
11103
11104   search_not_done--;
11105
11106   /* We're done. Reset the searched classes list and finally search
11107      java.lang.Object if it wasn't searched already. */
11108   if (!search_not_done)
11109     {
11110       if (!lc
11111           && TYPE_METHODS (object_type_node)
11112           && htab_find (searched_classes, object_type_node) == NULL)
11113         {
11114           search_applicable_methods_list (lc,
11115                                           TYPE_METHODS (object_type_node),
11116                                           name, arglist, &list, &all_list);
11117         }
11118       htab_delete (searched_classes);
11119       searched_classes = NULL;
11120     }
11121
11122   /* Either return the list obtained or all selected (but
11123      inaccessible) methods for better error report. */
11124   return (!list ? all_list : list);
11125 }
11126
11127 /* Effectively search for the appropriate method in method */
11128
11129 static void
11130 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11131                                 tree *list, tree *all_list)
11132 {
11133   for (; method; method = TREE_CHAIN (method))
11134     {
11135       /* When dealing with constructor, stop here, otherwise search
11136          other classes */
11137       if (lc && !DECL_CONSTRUCTOR_P (method))
11138         continue;
11139       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11140                        || (DECL_NAME (method) != name)))
11141         continue;
11142
11143       if (argument_types_convertible (method, arglist))
11144         {
11145           /* Retain accessible methods only */
11146           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11147                                  method, NULL_TREE, 0))
11148             *list = tree_cons (NULL_TREE, method, *list);
11149           else
11150             /* Also retain all selected method here */
11151             *all_list = tree_cons (NULL_TREE, method, *list);
11152         }
11153     }
11154 }
11155
11156 /* 15.11.2.2 Choose the Most Specific Method */
11157
11158 static tree
11159 find_most_specific_methods_list (tree list)
11160 {
11161   int max = 0;
11162   int abstract, candidates;
11163   tree current, new_list = NULL_TREE;
11164   for (current = list; current; current = TREE_CHAIN (current))
11165     {
11166       tree method;
11167       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11168
11169       for (method = list; method; method = TREE_CHAIN (method))
11170         {
11171           tree method_v, current_v;
11172           /* Don't test a method against itself */
11173           if (method == current)
11174             continue;
11175
11176           method_v = TREE_VALUE (method);
11177           current_v = TREE_VALUE (current);
11178
11179           /* Compare arguments and location where methods where declared */
11180           if (argument_types_convertible (method_v, current_v))
11181             {
11182               if (valid_method_invocation_conversion_p
11183                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11184                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11185                       && enclosing_context_p (DECL_CONTEXT (method_v),
11186                                               DECL_CONTEXT (current_v))))
11187                 {
11188                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
11189                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11190                   max = (v > max ? v : max);
11191                 }
11192             }
11193         }
11194     }
11195
11196   /* Review the list and select the maximally specific methods */
11197   for (current = list, abstract = -1, candidates = -1;
11198        current; current = TREE_CHAIN (current))
11199     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11200       {
11201         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11202         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11203         candidates++;
11204       }
11205
11206   /* If we have several and they're all abstract, just pick the
11207      closest one. */
11208   if (candidates > 0 && candidates == abstract)
11209     {
11210       /* FIXME: merge the throws clauses.  There is no convenient way
11211          to do this in gcj right now, since ideally we'd like to
11212          introduce a new METHOD_DECL here, but that is really not
11213          possible.  */
11214       new_list = nreverse (new_list);
11215       TREE_CHAIN (new_list) = NULL_TREE;
11216       return new_list;
11217     }
11218
11219   /* We have several (we couldn't find a most specific), all but one
11220      are abstract, we pick the only non abstract one. */
11221   if (candidates > 0 && (candidates == abstract+1))
11222     {
11223       for (current = new_list; current; current = TREE_CHAIN (current))
11224         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11225           {
11226             TREE_CHAIN (current) = NULL_TREE;
11227             new_list = current;
11228           }
11229     }
11230
11231   /* If we can't find one, lower expectations and try to gather multiple
11232      maximally specific methods */
11233   while (!new_list && max)
11234     {
11235       while (--max > 0)
11236         {
11237           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11238             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11239         }
11240     }
11241
11242   return new_list;
11243 }
11244
11245 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11246    converted by method invocation conversion (5.3) to the type of the
11247    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11248    to change less often than M1. */
11249
11250 static GTY(()) tree m2_arg_value;
11251 static GTY(()) tree m2_arg_cache;
11252
11253 static int
11254 argument_types_convertible (tree m1, tree m2_or_arglist)
11255 {
11256   tree m1_arg, m2_arg;
11257
11258   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11259
11260   if (m2_arg_value == m2_or_arglist)
11261     m2_arg = m2_arg_cache;
11262   else
11263     {
11264       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11265          argument types */
11266       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11267         {
11268           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11269           if (!METHOD_STATIC (m2_or_arglist))
11270             m2_arg = TREE_CHAIN (m2_arg);
11271         }
11272       else
11273         m2_arg = m2_or_arglist;
11274
11275       m2_arg_value = m2_or_arglist;
11276       m2_arg_cache = m2_arg;
11277     }
11278
11279   while (m1_arg != end_params_node && m2_arg != end_params_node)
11280     {
11281       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11282       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11283                                                  TREE_VALUE (m2_arg)))
11284         break;
11285       m1_arg = TREE_CHAIN (m1_arg);
11286       m2_arg = TREE_CHAIN (m2_arg);
11287     }
11288   return m1_arg == end_params_node && m2_arg == end_params_node;
11289 }
11290
11291 /* Qualification routines */
11292
11293 /* Given a name x.y.z, look up x locally.  If it's found, save the
11294    decl.  If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11295    so that we later try and load the appropriate classes.  */
11296 static void
11297 qualify_ambiguous_name (tree id)
11298 {
11299   tree name, decl;
11300
11301   /* We inspect the first item of the qualification list.  As a sanity
11302      check, make sure that it is an identfier node.  */
11303   tree qual = EXPR_WFL_QUALIFICATION (id);
11304   tree qual_wfl = QUAL_WFL (qual);
11305
11306   if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11307     return;
11308
11309   name = EXPR_WFL_NODE (qual_wfl);
11310
11311   /* If we don't have an identifier, or we have a 'this' or 'super',
11312      then field access processing is all we need : there is nothing
11313      for us to do.  */
11314   if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11315       name == this_identifier_node ||
11316       name == super_identifier_node)
11317     return;
11318
11319   /* If name appears within the scope of a local variable declaration
11320      or parameter declaration, or is a field within an enclosing
11321      class, then it is an expression name.  Save the decl and let
11322      resolve_field_access do it's work.  */
11323   if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11324       (decl = lookup_field_wrapper (current_class, name)))
11325     {
11326       QUAL_RESOLUTION (qual) = decl;
11327       return;
11328     }
11329
11330   /* If name is a known class name (either declared or imported), mark
11331      us as a type name.  */
11332   if ((decl = resolve_and_layout (name, NULL_TREE)))
11333     {
11334       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11335       QUAL_RESOLUTION (qual) = decl;
11336     }
11337
11338   /* Check here that NAME isn't declared by more than one
11339      type-import-on-demand declaration of the compilation unit
11340      containing NAME. FIXME */
11341
11342   /* We couldn't find a declaration for the name.  Assume for now that
11343      we have a qualified class name that needs to be loaded from an
11344      external class file.  */
11345   else
11346     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11347
11348   /* Propagate the qualification across other components of the
11349      qualified name */
11350   for (qual = TREE_CHAIN (qual); qual;
11351        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11352     {
11353       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11354         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11355     }
11356
11357   /* Store the global qualification for the ambiguous part of ID back
11358      into ID fields */
11359   if (RESOLVE_TYPE_NAME_P (qual_wfl))
11360     RESOLVE_TYPE_NAME_P (id) = 1;
11361   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11362     RESOLVE_PACKAGE_NAME_P (id) = 1;
11363 }
11364
11365 static int
11366 breakdown_qualified (tree *left, tree *right, tree source)
11367 {
11368   char *p, *base;
11369   int l = IDENTIFIER_LENGTH (source);
11370
11371   base = alloca (l + 1);
11372   memcpy (base, IDENTIFIER_POINTER (source), l + 1);
11373
11374   /* Breakdown NAME into REMAINDER . IDENTIFIER.  */
11375   p = base + l - 1;
11376   while (*p != '.' && p != base)
11377     p--;
11378
11379   /* We didn't find a '.'. Return an error.  */
11380   if (p == base)
11381     return 1;
11382
11383   *p = '\0';
11384   if (right)
11385     *right = get_identifier (p+1);
11386   *left = get_identifier (base);
11387
11388   return 0;
11389 }
11390
11391 /* Return TRUE if two classes are from the same package. */
11392
11393 static int
11394 in_same_package (tree name1, tree name2)
11395 {
11396   tree tmp;
11397   tree pkg1;
11398   tree pkg2;
11399
11400   if (TREE_CODE (name1) == TYPE_DECL)
11401     name1 = DECL_NAME (name1);
11402   if (TREE_CODE (name2) == TYPE_DECL)
11403     name2 = DECL_NAME (name2);
11404
11405   if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
11406     /* One in empty package. */
11407     return 0;
11408
11409   if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
11410     /* Both in empty package. */
11411     return 1;
11412
11413   breakdown_qualified (&pkg1, &tmp, name1);
11414   breakdown_qualified (&pkg2, &tmp, name2);
11415
11416   return (pkg1 == pkg2);
11417 }
11418
11419 /* Patch tree nodes in a function body. When a BLOCK is found, push
11420    local variable decls if present.
11421    Same as java_complete_lhs, but does resolve static finals to values. */
11422
11423 static tree
11424 java_complete_tree (tree node)
11425 {
11426   node = java_complete_lhs (node);
11427   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11428       && DECL_INITIAL (node) != NULL_TREE
11429       && !flag_emit_xref)
11430     {
11431       tree value = fold_constant_for_init (node, node);
11432       if (value != NULL_TREE)
11433         return value;
11434     }
11435   return node;
11436 }
11437
11438 static tree
11439 java_stabilize_reference (tree node)
11440 {
11441   if (TREE_CODE (node) == COMPOUND_EXPR)
11442     {
11443       tree op0 = TREE_OPERAND (node, 0);
11444       tree op1 = TREE_OPERAND (node, 1);
11445       TREE_OPERAND (node, 0) = save_expr (op0);
11446       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11447       return node;
11448     }
11449   return stabilize_reference (node);
11450 }
11451
11452 /* Patch tree nodes in a function body. When a BLOCK is found, push
11453    local variable decls if present.
11454    Same as java_complete_tree, but does not resolve static finals to values. */
11455
11456 static tree
11457 java_complete_lhs (tree node)
11458 {
11459   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11460   int flag;
11461
11462   /* CONVERT_EXPR always has its type set, even though it needs to be
11463      worked out. */
11464   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11465     return node;
11466
11467   /* The switch block implements cases processing container nodes
11468      first.  Contained nodes are always written back. Leaves come
11469      next and return a value. */
11470   switch (TREE_CODE (node))
11471     {
11472     case BLOCK:
11473
11474       /* 1- Block section.
11475          Set the local values on decl names so we can identify them
11476          faster when they're referenced. At that stage, identifiers
11477          are legal so we don't check for declaration errors. */
11478       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11479         {
11480           DECL_CONTEXT (cn) = current_function_decl;
11481           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11482         }
11483       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11484           CAN_COMPLETE_NORMALLY (node) = 1;
11485       else
11486         {
11487           tree stmt = BLOCK_EXPR_BODY (node);
11488           tree *ptr;
11489           int error_seen = 0;
11490           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11491             {
11492               /* Re-order from (((A; B); C); ...; Z) to
11493                  (A; (B; (C ; (...; Z)))).
11494                  This makes it easier to scan the statements left-to-right
11495                  without using recursion (which might overflow the stack
11496                  if the block has many statements. */
11497               for (;;)
11498                 {
11499                   tree left = TREE_OPERAND (stmt, 0);
11500                   if (TREE_CODE (left) != COMPOUND_EXPR)
11501                     break;
11502                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11503                   TREE_OPERAND (left, 1) = stmt;
11504                   stmt = left;
11505                 }
11506               BLOCK_EXPR_BODY (node) = stmt;
11507             }
11508
11509           /* Now do the actual complete, without deep recursion for
11510              long blocks. */
11511           ptr = &BLOCK_EXPR_BODY (node);
11512           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11513                  && !IS_EMPTY_STMT (TREE_OPERAND (*ptr, 1)))
11514             {
11515               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11516               tree *next = &TREE_OPERAND (*ptr, 1);
11517               TREE_OPERAND (*ptr, 0) = cur;
11518               if (IS_EMPTY_STMT (cur))
11519                 {
11520                   /* Optimization;  makes it easier to detect empty bodies.
11521                      Most useful for <clinit> with all-constant initializer. */
11522                   *ptr = *next;
11523                   continue;
11524                 }
11525               if (TREE_CODE (cur) == ERROR_MARK)
11526                 error_seen++;
11527               else if (! CAN_COMPLETE_NORMALLY (cur))
11528                 {
11529                   wfl_op2 = *next;
11530                   for (;;)
11531                     {
11532                       if (TREE_CODE (wfl_op2) == BLOCK)
11533                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11534                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11535                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11536                       else
11537                         break;
11538                     }
11539                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11540                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11541                     unreachable_stmt_error (*ptr);
11542                 }
11543               if (TREE_TYPE (*ptr) == NULL_TREE)
11544                 TREE_TYPE (*ptr) = void_type_node;
11545               ptr = next;
11546             }
11547           *ptr = java_complete_tree (*ptr);
11548
11549           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11550             return error_mark_node;
11551           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11552         }
11553       /* Turn local bindings to null */
11554       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11555         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11556
11557       TREE_TYPE (node) = void_type_node;
11558       break;
11559
11560       /* 2- They are expressions but ultimately deal with statements */
11561
11562     case THROW_EXPR:
11563       wfl_op1 = TREE_OPERAND (node, 0);
11564       COMPLETE_CHECK_OP_0 (node);
11565       /* 14.19 A throw statement cannot complete normally. */
11566       CAN_COMPLETE_NORMALLY (node) = 0;
11567       return patch_throw_statement (node, wfl_op1);
11568
11569     case SYNCHRONIZED_EXPR:
11570       wfl_op1 = TREE_OPERAND (node, 0);
11571       return patch_synchronized_statement (node, wfl_op1);
11572
11573     case TRY_EXPR:
11574       return patch_try_statement (node);
11575
11576     case TRY_FINALLY_EXPR:
11577       COMPLETE_CHECK_OP_0 (node);
11578       COMPLETE_CHECK_OP_1 (node);
11579       if (IS_EMPTY_STMT (TREE_OPERAND (node, 0)))
11580         /* Reduce try/finally nodes with an empty try block.  */
11581         return TREE_OPERAND (node, 1);
11582       if (IS_EMPTY_STMT (TREE_OPERAND (node, 1)))
11583         /* Likewise for an empty finally block.  */
11584         return TREE_OPERAND (node, 0);
11585       CAN_COMPLETE_NORMALLY (node)
11586         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11587            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11588       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11589       return node;
11590
11591     case LABELED_BLOCK_EXPR:
11592       PUSH_LABELED_BLOCK (node);
11593       if (LABELED_BLOCK_BODY (node))
11594         COMPLETE_CHECK_OP_1 (node);
11595       TREE_TYPE (node) = void_type_node;
11596       POP_LABELED_BLOCK ();
11597
11598       if (IS_EMPTY_STMT (LABELED_BLOCK_BODY (node)))
11599         {
11600           LABELED_BLOCK_BODY (node) = NULL_TREE;
11601           CAN_COMPLETE_NORMALLY (node) = 1;
11602         }
11603       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11604         CAN_COMPLETE_NORMALLY (node) = 1;
11605       return node;
11606
11607     case EXIT_BLOCK_EXPR:
11608       /* We don't complete operand 1, because it's the return value of
11609          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11610       return patch_bc_statement (node);
11611
11612     case CASE_EXPR:
11613       cn = java_complete_tree (TREE_OPERAND (node, 0));
11614       if (cn == error_mark_node)
11615         return cn;
11616
11617       /* First, the case expression must be constant. Values of final
11618          fields are accepted. */
11619       cn = fold (cn);
11620       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11621           && JDECL_P (TREE_OPERAND (cn, 1))
11622           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11623           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11624         {
11625           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11626                                        TREE_OPERAND (cn, 1));
11627         }
11628       /* Accept final locals too. */
11629       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn)
11630                && DECL_INITIAL (cn))
11631         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11632
11633       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11634         {
11635           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11636           parse_error_context (node, "Constant expression required");
11637           return error_mark_node;
11638         }
11639
11640       nn = ctxp->current_loop;
11641
11642       /* It must be assignable to the type of the switch expression. */
11643       if (!try_builtin_assignconv (NULL_TREE,
11644                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11645         {
11646           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11647           parse_error_context
11648             (wfl_operator,
11649              "Incompatible type for case. Can't convert `%s' to `int'",
11650              lang_printable_name (TREE_TYPE (cn), 0));
11651           return error_mark_node;
11652         }
11653
11654       cn = fold (convert (int_type_node, cn));
11655       TREE_CONSTANT_OVERFLOW (cn) = 0;
11656       CAN_COMPLETE_NORMALLY (cn) = 1;
11657
11658       /* Save the label on a list so that we can later check for
11659          duplicates.  */
11660       case_label_list = tree_cons (node, cn, case_label_list);
11661
11662       /* Multiple instance of a case label bearing the same value is
11663          checked later. The case expression is all right so far. */
11664       if (TREE_CODE (cn) == VAR_DECL)
11665         cn = DECL_INITIAL (cn);
11666       TREE_OPERAND (node, 0) = cn;
11667       TREE_TYPE (node) = void_type_node;
11668       CAN_COMPLETE_NORMALLY (node) = 1;
11669       TREE_SIDE_EFFECTS (node) = 1;
11670       break;
11671
11672     case DEFAULT_EXPR:
11673       nn = ctxp->current_loop;
11674       /* Only one default label is allowed per switch statement */
11675       if (SWITCH_HAS_DEFAULT (nn))
11676         {
11677           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11678           parse_error_context (wfl_operator,
11679                                "Duplicate case label: `default'");
11680           return error_mark_node;
11681         }
11682       else
11683         SWITCH_HAS_DEFAULT (nn) = 1;
11684       TREE_TYPE (node) = void_type_node;
11685       TREE_SIDE_EFFECTS (node) = 1;
11686       CAN_COMPLETE_NORMALLY (node) = 1;
11687       break;
11688
11689     case SWITCH_EXPR:
11690     case LOOP_EXPR:
11691       PUSH_LOOP (node);
11692       /* Check whether the loop was enclosed in a labeled
11693          statement. If not, create one, insert the loop in it and
11694          return the node */
11695       nn = patch_loop_statement (node);
11696
11697       /* Anyways, walk the body of the loop */
11698       if (TREE_CODE (node) == LOOP_EXPR)
11699         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11700       /* Switch statement: walk the switch expression and the cases */
11701       else
11702         node = patch_switch_statement (node);
11703
11704       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11705         nn = error_mark_node;
11706       else
11707         {
11708           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11709           /* If we returned something different, that's because we
11710              inserted a label. Pop the label too. */
11711           if (nn != node)
11712             {
11713               if (CAN_COMPLETE_NORMALLY (node))
11714                 CAN_COMPLETE_NORMALLY (nn) = 1;
11715               POP_LABELED_BLOCK ();
11716             }
11717         }
11718       POP_LOOP ();
11719       return nn;
11720
11721     case EXIT_EXPR:
11722       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11723       return patch_exit_expr (node);
11724
11725     case COND_EXPR:
11726       /* Condition */
11727       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11728       if (TREE_OPERAND (node, 0) == error_mark_node)
11729         return error_mark_node;
11730       /* then-else branches */
11731       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11732       if (TREE_OPERAND (node, 1) == error_mark_node)
11733         return error_mark_node;
11734       TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11735       if (TREE_OPERAND (node, 2) == error_mark_node)
11736         return error_mark_node;
11737       return patch_if_else_statement (node);
11738       break;
11739
11740     case CONDITIONAL_EXPR:
11741       /* Condition */
11742       wfl_op1 = TREE_OPERAND (node, 0);
11743       COMPLETE_CHECK_OP_0 (node);
11744       wfl_op2 = TREE_OPERAND (node, 1);
11745       COMPLETE_CHECK_OP_1 (node);
11746       wfl_op3 = TREE_OPERAND (node, 2);
11747       COMPLETE_CHECK_OP_2 (node);
11748       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11749
11750       /* 3- Expression section */
11751     case COMPOUND_EXPR:
11752       wfl_op2 = TREE_OPERAND (node, 1);
11753       TREE_OPERAND (node, 0) = nn =
11754         java_complete_tree (TREE_OPERAND (node, 0));
11755       if (IS_EMPTY_STMT (wfl_op2))
11756         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11757       else
11758         {
11759           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11760             {
11761               /* An unreachable condition in a do-while statement
11762                  is *not* (technically) an unreachable statement. */
11763               nn = wfl_op2;
11764               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11765                 nn = EXPR_WFL_NODE (nn);
11766               /* NN can be NULL_TREE exactly when UPDATE is, in
11767                  finish_for_loop.  */
11768               if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11769                 {
11770                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11771                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11772                     {
11773                       /* Perhaps this warning should have an
11774                          associated flag.  The code being compiled is
11775                          pedantically correct, but useless.  */
11776                       parse_warning_context (wfl_operator,
11777                                              "Unreachable statement");
11778                     }
11779                   else
11780                     parse_error_context (wfl_operator,
11781                                          "Unreachable statement");
11782                 }
11783             }
11784           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11785           if (TREE_OPERAND (node, 1) == error_mark_node)
11786             return error_mark_node;
11787           /* Even though we might allow the case where the first
11788              operand doesn't return normally, we still should compute
11789              CAN_COMPLETE_NORMALLY correctly.  */
11790           CAN_COMPLETE_NORMALLY (node)
11791             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11792                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11793         }
11794       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11795       break;
11796
11797     case RETURN_EXPR:
11798       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11799       return patch_return (node);
11800
11801     case EXPR_WITH_FILE_LOCATION:
11802       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11803           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11804         {
11805           tree wfl = node;
11806           node = resolve_expression_name (node, NULL);
11807           if (node == error_mark_node)
11808             return node;
11809           /* Keep line number information somewhere were it doesn't
11810              disrupt the completion process. */
11811           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11812             {
11813               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11814               TREE_OPERAND (node, 1) = wfl;
11815             }
11816           CAN_COMPLETE_NORMALLY (node) = 1;
11817         }
11818       else
11819         {
11820           tree body;
11821           int save_lineno = input_line;
11822           input_line = EXPR_WFL_LINENO (node);
11823           body = java_complete_tree (EXPR_WFL_NODE (node));
11824           input_line = save_lineno;
11825           EXPR_WFL_NODE (node) = body;
11826           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11827           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11828           if (IS_EMPTY_STMT (body) || TREE_CONSTANT (body))
11829             {
11830               /* Makes it easier to constant fold, detect empty bodies. */
11831               return body;
11832             }
11833           if (body == error_mark_node)
11834             {
11835               /* Its important for the evaluation of assignment that
11836                  this mark on the TREE_TYPE is propagated. */
11837               TREE_TYPE (node) = error_mark_node;
11838               return error_mark_node;
11839             }
11840           else
11841             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11842
11843         }
11844       break;
11845
11846     case NEW_ARRAY_EXPR:
11847       /* Patch all the dimensions */
11848       flag = 0;
11849       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11850         {
11851           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11852           tree dim = convert (int_type_node,
11853                               java_complete_tree (TREE_VALUE (cn)));
11854           if (dim == error_mark_node)
11855             {
11856               flag = 1;
11857               continue;
11858             }
11859           else
11860             {
11861               TREE_VALUE (cn) = dim;
11862               /* Setup the location of the current dimension, for
11863                  later error report. */
11864               TREE_PURPOSE (cn) =
11865                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11866               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11867             }
11868         }
11869       /* They complete the array creation expression, if no errors
11870          were found. */
11871       CAN_COMPLETE_NORMALLY (node) = 1;
11872       return (flag ? error_mark_node
11873               : force_evaluation_order (patch_newarray (node)));
11874
11875     case NEW_ANONYMOUS_ARRAY_EXPR:
11876       /* Create the array type if necessary. */
11877       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11878         {
11879           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11880           if (!(type = resolve_type_during_patch (type)))
11881             return error_mark_node;
11882           type = build_array_from_name (type, NULL_TREE,
11883                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11884           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11885         }
11886       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11887                                    ANONYMOUS_ARRAY_INITIALIZER (node));
11888       if (node == error_mark_node)
11889         return error_mark_node;
11890       CAN_COMPLETE_NORMALLY (node) = 1;
11891       return node;
11892
11893     case NEW_CLASS_EXPR:
11894     case CALL_EXPR:
11895       /* Complete function's argument(s) first */
11896       if (complete_function_arguments (node))
11897         return error_mark_node;
11898       else
11899         {
11900           tree decl, wfl = TREE_OPERAND (node, 0);
11901           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11902           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11903                            super_identifier_node);
11904           tree arguments;
11905           int location = EXPR_WFL_LINECOL (node);
11906
11907           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11908                                           from_super, 0, &decl);
11909           if (node == error_mark_node)
11910             return error_mark_node;
11911
11912           if (TREE_CODE (node) == CALL_EXPR
11913               && TREE_OPERAND (node, 1) != NULL_TREE)
11914             arguments = TREE_VALUE (TREE_OPERAND (node, 1));
11915           else
11916             arguments = NULL_TREE;
11917           check_thrown_exceptions (location, decl, arguments);
11918           /* If we call this(...), register signature and positions */
11919           if (in_this)
11920             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11921               tree_cons (wfl, decl,
11922                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
11923           CAN_COMPLETE_NORMALLY (node) = 1;
11924           return force_evaluation_order (node);
11925         }
11926
11927     case MODIFY_EXPR:
11928       /* Save potential wfls */
11929       wfl_op1 = TREE_OPERAND (node, 0);
11930       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11931
11932       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11933           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11934           && DECL_INITIAL (nn) != NULL_TREE)
11935         {
11936           tree value;
11937
11938           value = fold_constant_for_init (nn, nn);
11939
11940           /* When we have a primitype type, or a string and we're not
11941              emitting a class file, we actually don't want to generate
11942              anything for the assignment. */
11943           if (value != NULL_TREE &&
11944               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
11945                (TREE_TYPE (value) == string_ptr_type_node &&
11946                 ! flag_emit_class_files)))
11947             {
11948               /* Prepare node for patch_assignment */
11949               TREE_OPERAND (node, 1) = value;
11950               /* Call patch assignment to verify the assignment */
11951               if (patch_assignment (node, wfl_op1) == error_mark_node)
11952                 return error_mark_node;
11953               /* Set DECL_INITIAL properly (a conversion might have
11954                  been decided by patch_assignment) and return the
11955                  empty statement. */
11956               else
11957                 {
11958                   tree patched = patch_string (TREE_OPERAND (node, 1));
11959                   if (patched)
11960                     DECL_INITIAL (nn) = patched;
11961                   else
11962                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11963                   DECL_FIELD_FINAL_IUD (nn) = 1;
11964                   return build_java_empty_stmt ();
11965                 }
11966             }
11967           if (! flag_emit_class_files)
11968             DECL_INITIAL (nn) = NULL_TREE;
11969         }
11970       wfl_op2 = TREE_OPERAND (node, 1);
11971
11972       if (TREE_OPERAND (node, 0) == error_mark_node)
11973         return error_mark_node;
11974
11975       flag = COMPOUND_ASSIGN_P (wfl_op2);
11976       if (flag)
11977         {
11978           /* This might break when accessing outer field from inner
11979              class. TESTME, FIXME */
11980           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
11981
11982           /* Hand stabilize the lhs on both places */
11983           TREE_OPERAND (node, 0) = lvalue;
11984           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
11985             (flag_emit_class_files ? lvalue : save_expr (lvalue));
11986
11987           /* 15.25.2.a: Left hand is not an array access. FIXME */
11988           /* Now complete the RHS. We write it back later on. */
11989           nn = java_complete_tree (TREE_OPERAND (node, 1));
11990
11991           if ((cn = patch_string (nn)))
11992             nn = cn;
11993
11994           /* The last part of the rewrite for E1 op= E2 is to have
11995              E1 = (T)(E1 op E2), with T being the type of E1. */
11996           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
11997                                                TREE_TYPE (lvalue), nn));
11998
11999           /* If the assignment is compound and has reference type,
12000              then ensure the LHS has type String and nothing else.  */
12001           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
12002               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
12003             parse_error_context (wfl_op2,
12004                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
12005                                  lang_printable_name (TREE_TYPE (lvalue), 0));
12006
12007           /* 15.25.2.b: Left hand is an array access. FIXME */
12008         }
12009
12010       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12011          function to complete this RHS. Note that a NEW_ARRAY_INIT
12012          might have been already fully expanded if created as a result
12013          of processing an anonymous array initializer. We avoid doing
12014          the operation twice by testing whether the node already bears
12015          a type. */
12016       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12017         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12018                                    TREE_OPERAND (node, 1));
12019       /* Otherwise we simply complete the RHS */
12020       else
12021         nn = java_complete_tree (TREE_OPERAND (node, 1));
12022
12023       if (nn == error_mark_node)
12024         return error_mark_node;
12025
12026       /* Write back the RHS as we evaluated it. */
12027       TREE_OPERAND (node, 1) = nn;
12028
12029       /* In case we're handling = with a String as a RHS, we need to
12030          produce a String out of the RHS (it might still be a
12031          STRING_CST or a StringBuffer at this stage */
12032       if ((nn = patch_string (TREE_OPERAND (node, 1))))
12033         TREE_OPERAND (node, 1) = nn;
12034
12035       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12036                                         TREE_OPERAND (node, 1))))
12037         {
12038           /* We return error_mark_node if outer_field_access_fix
12039              detects we write into a final. */
12040           if (nn == error_mark_node)
12041             return error_mark_node;
12042           node = nn;
12043         }
12044       else
12045         {
12046           node = patch_assignment (node, wfl_op1);
12047           if (node == error_mark_node)
12048             return error_mark_node;
12049           /* Reorganize the tree if necessary. */
12050           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12051                        || JSTRING_P (TREE_TYPE (node))))
12052             node = java_refold (node);
12053         }
12054
12055       /* Seek to set DECL_INITIAL to a proper value, since it might have
12056          undergone a conversion in patch_assignment. We do that only when
12057          it's necessary to have DECL_INITIAL properly set. */
12058       nn = TREE_OPERAND (node, 0);
12059       if (TREE_CODE (nn) == VAR_DECL
12060           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12061           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12062           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12063               || TREE_TYPE (nn) == string_ptr_type_node))
12064         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12065
12066       CAN_COMPLETE_NORMALLY (node) = 1;
12067       return node;
12068
12069     case MULT_EXPR:
12070     case PLUS_EXPR:
12071     case MINUS_EXPR:
12072     case LSHIFT_EXPR:
12073     case RSHIFT_EXPR:
12074     case URSHIFT_EXPR:
12075     case BIT_AND_EXPR:
12076     case BIT_XOR_EXPR:
12077     case BIT_IOR_EXPR:
12078     case TRUNC_MOD_EXPR:
12079     case TRUNC_DIV_EXPR:
12080     case RDIV_EXPR:
12081     case TRUTH_ANDIF_EXPR:
12082     case TRUTH_ORIF_EXPR:
12083     case EQ_EXPR:
12084     case NE_EXPR:
12085     case GT_EXPR:
12086     case GE_EXPR:
12087     case LT_EXPR:
12088     case LE_EXPR:
12089       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12090          knows how to handle those cases. */
12091       wfl_op1 = TREE_OPERAND (node, 0);
12092       wfl_op2 = TREE_OPERAND (node, 1);
12093
12094       CAN_COMPLETE_NORMALLY (node) = 1;
12095       /* Don't complete string nodes if dealing with the PLUS operand. */
12096       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12097         {
12098           nn = java_complete_tree (wfl_op1);
12099           if (nn == error_mark_node)
12100             return error_mark_node;
12101
12102           TREE_OPERAND (node, 0) = nn;
12103         }
12104       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12105         {
12106           nn = java_complete_tree (wfl_op2);
12107           if (nn == error_mark_node)
12108             return error_mark_node;
12109
12110           TREE_OPERAND (node, 1) = nn;
12111         }
12112       return patch_binop (node, wfl_op1, wfl_op2);
12113
12114     case INSTANCEOF_EXPR:
12115       wfl_op1 = TREE_OPERAND (node, 0);
12116       COMPLETE_CHECK_OP_0 (node);
12117       if (flag_emit_xref)
12118         {
12119           TREE_TYPE (node) = boolean_type_node;
12120           return node;
12121         }
12122       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12123
12124     case UNARY_PLUS_EXPR:
12125     case NEGATE_EXPR:
12126     case TRUTH_NOT_EXPR:
12127     case BIT_NOT_EXPR:
12128     case PREDECREMENT_EXPR:
12129     case PREINCREMENT_EXPR:
12130     case POSTDECREMENT_EXPR:
12131     case POSTINCREMENT_EXPR:
12132     case CONVERT_EXPR:
12133       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12134          how to handle those cases. */
12135       wfl_op1 = TREE_OPERAND (node, 0);
12136       CAN_COMPLETE_NORMALLY (node) = 1;
12137       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12138       if (TREE_OPERAND (node, 0) == error_mark_node)
12139         return error_mark_node;
12140       node = patch_unaryop (node, wfl_op1);
12141       CAN_COMPLETE_NORMALLY (node) = 1;
12142       break;
12143
12144     case ARRAY_REF:
12145       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12146          how to handle those cases. */
12147       wfl_op1 = TREE_OPERAND (node, 0);
12148       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12149       if (TREE_OPERAND (node, 0) == error_mark_node)
12150         return error_mark_node;
12151       if (!flag_emit_class_files && !flag_emit_xref)
12152         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12153       /* The same applies to wfl_op2 */
12154       wfl_op2 = TREE_OPERAND (node, 1);
12155       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12156       if (TREE_OPERAND (node, 1) == error_mark_node)
12157         return error_mark_node;
12158       if (!flag_emit_class_files && !flag_emit_xref)
12159         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12160       return patch_array_ref (node);
12161
12162     case RECORD_TYPE:
12163       return node;;
12164
12165     case COMPONENT_REF:
12166       /* The first step in the re-write of qualified name handling.  FIXME.
12167          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12168       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12169       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12170         {
12171           tree name = TREE_OPERAND (node, 1);
12172           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12173           if (field == NULL_TREE)
12174             {
12175               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12176               return error_mark_node;
12177             }
12178           if (! FIELD_STATIC (field))
12179             {
12180               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12181               return error_mark_node;
12182             }
12183           return field;
12184         }
12185       else
12186         abort ();
12187       break;
12188
12189     case THIS_EXPR:
12190       /* Can't use THIS in a static environment */
12191       if (!current_this)
12192         {
12193           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12194           parse_error_context (wfl_operator,
12195                                "Keyword `this' used outside allowed context");
12196           TREE_TYPE (node) = error_mark_node;
12197           return error_mark_node;
12198         }
12199       if (ctxp->explicit_constructor_p)
12200         {
12201           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12202           parse_error_context
12203             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12204           TREE_TYPE (node) = error_mark_node;
12205           return error_mark_node;
12206         }
12207       return current_this;
12208
12209     case CLASS_LITERAL:
12210       CAN_COMPLETE_NORMALLY (node) = 1;
12211       node = patch_incomplete_class_ref (node);
12212       if (node == error_mark_node)
12213         return error_mark_node;
12214       break;
12215
12216     default:
12217       CAN_COMPLETE_NORMALLY (node) = 1;
12218       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12219          and it's time to turn it into the appropriate String object */
12220       if ((nn = patch_string (node)))
12221         node = nn;
12222       else
12223         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12224     }
12225   return node;
12226 }
12227
12228 /* Complete function call's argument. Return a nonzero value is an
12229    error was found.  */
12230
12231 static int
12232 complete_function_arguments (tree node)
12233 {
12234   int flag = 0;
12235   tree cn;
12236
12237   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12238   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12239     {
12240       tree wfl = TREE_VALUE (cn), parm, temp;
12241       parm = java_complete_tree (wfl);
12242
12243       if (parm == error_mark_node)
12244         {
12245           flag = 1;
12246           continue;
12247         }
12248       /* If have a string literal that we haven't transformed yet or a
12249          crafted string buffer, as a result of use of the the String
12250          `+' operator. Build `parm.toString()' and expand it. */
12251       if ((temp = patch_string (parm)))
12252         parm = temp;
12253
12254       TREE_VALUE (cn) = parm;
12255     }
12256   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12257   return flag;
12258 }
12259
12260 /* Sometimes (for loops and variable initialized during their
12261    declaration), we want to wrap a statement around a WFL and turn it
12262    debugable.  */
12263
12264 static tree
12265 build_debugable_stmt (int location, tree stmt)
12266 {
12267   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12268     {
12269       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12270       EXPR_WFL_LINECOL (stmt) = location;
12271     }
12272   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12273   return stmt;
12274 }
12275
12276 static tree
12277 build_expr_block (tree body, tree decls)
12278
12279 {
12280   tree node = make_node (BLOCK);
12281   BLOCK_EXPR_DECLS (node) = decls;
12282   BLOCK_EXPR_BODY (node) = body;
12283   if (body)
12284     TREE_TYPE (node) = TREE_TYPE (body);
12285   TREE_SIDE_EFFECTS (node) = 1;
12286   return node;
12287 }
12288
12289 /* Create a new function block and link it appropriately to current
12290    function block chain */
12291
12292 static tree
12293 enter_block (void)
12294 {
12295   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12296
12297   /* Link block B supercontext to the previous block. The current
12298      function DECL is used as supercontext when enter_a_block is called
12299      for the first time for a given function. The current function body
12300      (DECL_FUNCTION_BODY) is set to be block B.  */
12301
12302   tree fndecl = current_function_decl;
12303
12304   if (!fndecl) {
12305     BLOCK_SUPERCONTEXT (b) = current_static_block;
12306     current_static_block = b;
12307   }
12308
12309   else if (!DECL_FUNCTION_BODY (fndecl))
12310     {
12311       BLOCK_SUPERCONTEXT (b) = fndecl;
12312       DECL_FUNCTION_BODY (fndecl) = b;
12313     }
12314   else
12315     {
12316       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12317       DECL_FUNCTION_BODY (fndecl) = b;
12318     }
12319   return b;
12320 }
12321
12322 /* Exit a block by changing the current function body
12323    (DECL_FUNCTION_BODY) to the current block super context, only if
12324    the block being exited isn't the method's top level one.  */
12325
12326 static tree
12327 exit_block (void)
12328 {
12329   tree b;
12330   if (current_function_decl)
12331     {
12332       b = DECL_FUNCTION_BODY (current_function_decl);
12333       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12334         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12335     }
12336   else
12337     {
12338       b = current_static_block;
12339
12340       if (BLOCK_SUPERCONTEXT (b))
12341         current_static_block = BLOCK_SUPERCONTEXT (b);
12342     }
12343   return b;
12344 }
12345
12346 /* Lookup for NAME in the nested function's blocks, all the way up to
12347    the current toplevel one. It complies with Java's local variable
12348    scoping rules.  */
12349
12350 static tree
12351 lookup_name_in_blocks (tree name)
12352 {
12353   tree b = GET_CURRENT_BLOCK (current_function_decl);
12354
12355   while (b != current_function_decl)
12356     {
12357       tree current;
12358
12359       /* Paranoid sanity check. To be removed */
12360       if (TREE_CODE (b) != BLOCK)
12361         abort ();
12362
12363       for (current = BLOCK_EXPR_DECLS (b); current;
12364            current = TREE_CHAIN (current))
12365         if (DECL_NAME (current) == name)
12366           return current;
12367       b = BLOCK_SUPERCONTEXT (b);
12368     }
12369   return NULL_TREE;
12370 }
12371
12372 static void
12373 maybe_absorb_scoping_blocks (void)
12374 {
12375   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12376     {
12377       tree b = exit_block ();
12378       java_method_add_stmt (current_function_decl, b);
12379       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12380     }
12381 }
12382
12383 \f
12384 /* This section of the source is reserved to build_* functions that
12385    are building incomplete tree nodes and the patch_* functions that
12386    are completing them.  */
12387
12388 /* Wrap a non WFL node around a WFL.  */
12389
12390 static tree
12391 build_wfl_wrap (tree node, int location)
12392 {
12393   tree wfl, node_to_insert = node;
12394
12395   /* We want to process THIS . xxx symbolically, to keep it consistent
12396      with the way we're processing SUPER. A THIS from a primary as a
12397      different form than a SUPER. Turn THIS into something symbolic */
12398   if (TREE_CODE (node) == THIS_EXPR)
12399     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12400   else
12401     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12402
12403   EXPR_WFL_LINECOL (wfl) = location;
12404   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12405   return wfl;
12406 }
12407
12408 /* Build a super() constructor invocation. Returns an empty statement if
12409    we're currently dealing with the class java.lang.Object. */
12410
12411 static tree
12412 build_super_invocation (tree mdecl)
12413 {
12414   if (DECL_CONTEXT (mdecl) == object_type_node)
12415     return build_java_empty_stmt ();
12416   else
12417     {
12418       tree super_wfl = build_wfl_node (super_identifier_node);
12419       tree a = NULL_TREE, t;
12420       /* If we're dealing with an anonymous class, pass the arguments
12421          of the crafted constructor along. */
12422       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12423         {
12424           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12425           for (; t != end_params_node; t = TREE_CHAIN (t))
12426             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12427         }
12428       return build_method_invocation (super_wfl, a);
12429     }
12430 }
12431
12432 /* Build a SUPER/THIS qualified method invocation.  */
12433
12434 static tree
12435 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12436                                        int lloc, int rloc)
12437 {
12438   tree invok;
12439   tree wfl =
12440     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12441   EXPR_WFL_LINECOL (wfl) = lloc;
12442   invok = build_method_invocation (name, args);
12443   return make_qualified_primary (wfl, invok, rloc);
12444 }
12445
12446 /* Build an incomplete CALL_EXPR node. */
12447
12448 static tree
12449 build_method_invocation (tree name, tree args)
12450 {
12451   tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12452   TREE_SIDE_EFFECTS (call) = 1;
12453   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12454   return call;
12455 }
12456
12457 /* Build an incomplete new xxx(...) node. */
12458
12459 static tree
12460 build_new_invocation (tree name, tree args)
12461 {
12462   tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12463   TREE_SIDE_EFFECTS (call) = 1;
12464   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12465   return call;
12466 }
12467
12468 /* Build an incomplete assignment expression. */
12469
12470 static tree
12471 build_assignment (int op, int op_location, tree lhs, tree rhs)
12472 {
12473   tree assignment;
12474   /* Build the corresponding binop if we deal with a Compound
12475      Assignment operator. Mark the binop sub-tree as part of a
12476      Compound Assignment expression */
12477   if (op != ASSIGN_TK)
12478     {
12479       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12480       COMPOUND_ASSIGN_P (rhs) = 1;
12481     }
12482   assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12483   TREE_SIDE_EFFECTS (assignment) = 1;
12484   EXPR_WFL_LINECOL (assignment) = op_location;
12485   return assignment;
12486 }
12487
12488 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12489    the buffer.  This is used only for string conversion.  */
12490 static char *
12491 string_convert_int_cst (tree node)
12492 {
12493   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12494   static char buffer[21];
12495
12496   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12497   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12498   char *p = buffer + sizeof (buffer);
12499   int neg = 0;
12500
12501   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12502                                   << (HOST_BITS_PER_WIDE_INT - 1));
12503
12504   *--p = '\0';
12505
12506   /* If negative, note the fact and negate the value.  */
12507   if ((hi & hibit))
12508     {
12509       lo = ~lo;
12510       hi = ~hi;
12511       if (++lo == 0)
12512         ++hi;
12513       neg = 1;
12514     }
12515
12516   /* Divide by 10 until there are no bits left.  */
12517   do
12518     {
12519       unsigned HOST_WIDE_INT acc = 0;
12520       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12521       unsigned int i;
12522
12523       /* Use long division to compute the result and the remainder.  */
12524       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12525         {
12526           /* Shift a bit into accumulator.  */
12527           acc <<= 1;
12528           if ((hi & hibit))
12529             acc |= 1;
12530
12531           /* Shift the value.  */
12532           hi <<= 1;
12533           if ((lo & hibit))
12534             hi |= 1;
12535           lo <<= 1;
12536
12537           /* Shift the correct bit into the result.  */
12538           outhi <<= 1;
12539           if ((outlo & hibit))
12540             outhi |= 1;
12541           outlo <<= 1;
12542           if (acc >= 10)
12543             {
12544               acc -= 10;
12545               outlo |= 1;
12546             }
12547         }
12548
12549       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12550       *--p = '\060' + acc;
12551
12552       hi = outhi;
12553       lo = outlo;
12554     }
12555   while (hi || lo);
12556
12557   if (neg)
12558     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12559
12560   return p;
12561 }
12562
12563 /* Print an INTEGER_CST node in a static buffer, and return the
12564    buffer.  This is used only for error handling.  */
12565 char *
12566 print_int_node (tree node)
12567 {
12568   static char buffer [80];
12569   if (TREE_CONSTANT_OVERFLOW (node))
12570     sprintf (buffer, "<overflow>");
12571
12572   if (TREE_INT_CST_HIGH (node) == 0)
12573     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12574              TREE_INT_CST_LOW (node));
12575   else if (TREE_INT_CST_HIGH (node) == -1
12576            && TREE_INT_CST_LOW (node) != 0)
12577     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12578              -TREE_INT_CST_LOW (node));
12579   else
12580     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12581              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12582
12583   return buffer;
12584 }
12585
12586 \f
12587 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12588    context.  */
12589
12590 /* 15.25 Assignment operators. */
12591
12592 static tree
12593 patch_assignment (tree node, tree wfl_op1)
12594 {
12595   tree rhs = TREE_OPERAND (node, 1);
12596   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12597   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12598   int error_found = 0;
12599   int lvalue_from_array = 0;
12600   int is_return = 0;
12601
12602   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12603
12604   /* Lhs can be a named variable */
12605   if (JDECL_P (lvalue))
12606     {
12607       lhs_type = TREE_TYPE (lvalue);
12608     }
12609   /* Or Lhs can be an array access. */
12610   else if (TREE_CODE (lvalue) == ARRAY_REF)
12611     {
12612       lhs_type = TREE_TYPE (lvalue);
12613       lvalue_from_array = 1;
12614     }
12615   /* Or a field access */
12616   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12617     lhs_type = TREE_TYPE (lvalue);
12618   /* Or a function return slot */
12619   else if (TREE_CODE (lvalue) == RESULT_DECL)
12620     {
12621       /* If the return type is an integral type, then we create the
12622          RESULT_DECL with a promoted type, but we need to do these
12623          checks against the unpromoted type to ensure type safety.  So
12624          here we look at the real type, not the type of the decl we
12625          are modifying.  */
12626       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12627       is_return = 1;
12628     }
12629   /* Otherwise, we might want to try to write into an optimized static
12630      final, this is an of a different nature, reported further on. */
12631   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12632            && resolve_expression_name (wfl_op1, &llvalue))
12633     {
12634       lhs_type = TREE_TYPE (lvalue);
12635     }
12636   else
12637     {
12638       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12639       error_found = 1;
12640     }
12641
12642   rhs_type = TREE_TYPE (rhs);
12643
12644   /* 5.1 Try the assignment conversion for builtin type. */
12645   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12646
12647   /* 5.2 If it failed, try a reference conversion */
12648   if (!new_rhs)
12649     new_rhs = try_reference_assignconv (lhs_type, rhs);
12650
12651   /* 15.25.2 If we have a compound assignment, convert RHS into the
12652      type of the LHS */
12653   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12654     new_rhs = convert (lhs_type, rhs);
12655
12656   /* Explicit cast required. This is an error */
12657   if (!new_rhs)
12658     {
12659       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12660       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12661       tree wfl;
12662       char operation [32];      /* Max size known */
12663
12664       /* If the assignment is part of a declaration, we use the WFL of
12665          the declared variable to point out the error and call it a
12666          declaration problem. If the assignment is a genuine =
12667          operator, we call is a operator `=' problem, otherwise we
12668          call it an assignment problem. In both of these last cases,
12669          we use the WFL of the operator to indicate the error. */
12670
12671       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12672         {
12673           wfl = wfl_op1;
12674           strcpy (operation, "declaration");
12675         }
12676       else
12677         {
12678           wfl = wfl_operator;
12679           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12680             strcpy (operation, "assignment");
12681           else if (is_return)
12682             strcpy (operation, "`return'");
12683           else
12684             strcpy (operation, "`='");
12685         }
12686
12687       if (!valid_cast_to_p (rhs_type, lhs_type))
12688         parse_error_context
12689           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12690            operation, t1, t2);
12691       else
12692         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12693                              operation, t1, t2);
12694       free (t1); free (t2);
12695       error_found = 1;
12696     }
12697
12698   if (error_found)
12699     return error_mark_node;
12700
12701   /* If we're processing a `return' statement, promote the actual type
12702      to the promoted type.  */
12703   if (is_return)
12704     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12705
12706   /* 10.10: Array Store Exception runtime check */
12707   if (!flag_emit_class_files
12708       && !flag_emit_xref
12709       && lvalue_from_array
12710       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12711     {
12712       tree array, store_check, base, index_expr;
12713
12714       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12715       new_rhs = save_expr (new_rhs);
12716
12717       /* Get the INDIRECT_REF. */
12718       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12719       /* Get the array pointer expr. */
12720       array = TREE_OPERAND (array, 0);
12721       store_check = build_java_arraystore_check (array, new_rhs);
12722
12723       index_expr = TREE_OPERAND (lvalue, 1);
12724
12725       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12726         {
12727           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12728              happen before the store check, so prepare to insert the store
12729              check within the second operand of the existing COMPOUND_EXPR. */
12730           base = index_expr;
12731         }
12732       else
12733         base = lvalue;
12734
12735       index_expr = TREE_OPERAND (base, 1);
12736       TREE_OPERAND (base, 1) = build (COMPOUND_EXPR, TREE_TYPE (index_expr),
12737                                       store_check, index_expr);
12738     }
12739
12740   /* Final locals can be used as case values in switch
12741      statement. Prepare them for this eventuality. */
12742   if (TREE_CODE (lvalue) == VAR_DECL
12743       && DECL_FINAL (lvalue)
12744       && TREE_CONSTANT (new_rhs)
12745       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12746       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12747       )
12748     {
12749       TREE_CONSTANT (lvalue) = 1;
12750       TREE_INVARIANT (lvalue) = 1;
12751       DECL_INITIAL (lvalue) = new_rhs;
12752     }
12753
12754   /* Copy the rhs if it's a reference.  */
12755   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12756     {
12757       switch (TREE_CODE (new_rhs))
12758         {
12759         case ARRAY_REF:
12760         case INDIRECT_REF:
12761         case COMPONENT_REF:
12762           /* Transform a = foo.bar
12763              into a = ({int tmp; tmp = foo.bar;}).
12764              We need to ensure that if a read from memory fails
12765              because of a NullPointerException, a destination variable
12766              will remain unchanged.  An explicit temporary does what
12767              we need.
12768
12769              If flag_check_references is set, this is unnecessary
12770              because we'll check each reference before doing any
12771              reads.  If optimize is not set the result will never be
12772              written to a stack slot that contains the LHS.  */
12773           {
12774             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12775                                    TREE_TYPE (new_rhs));
12776             tree block = make_node (BLOCK);
12777             tree assignment
12778               = build (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12779             DECL_CONTEXT (tmp) = current_function_decl;
12780             TREE_TYPE (block) = TREE_TYPE (new_rhs);
12781             BLOCK_VARS (block) = tmp;
12782             BLOCK_EXPR_BODY (block) = assignment;
12783             TREE_SIDE_EFFECTS (block) = 1;
12784             new_rhs = block;
12785           }
12786           break;
12787         default:
12788           break;
12789         }
12790     }
12791
12792   TREE_OPERAND (node, 0) = lvalue;
12793   TREE_OPERAND (node, 1) = new_rhs;
12794   TREE_TYPE (node) = lhs_type;
12795   return node;
12796 }
12797
12798 /* Check that type SOURCE can be cast into type DEST. If the cast
12799    can't occur at all, return NULL; otherwise, return a possibly
12800    modified rhs.  */
12801
12802 static tree
12803 try_reference_assignconv (tree lhs_type, tree rhs)
12804 {
12805   tree new_rhs = NULL_TREE;
12806   tree rhs_type = TREE_TYPE (rhs);
12807
12808   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12809     {
12810       /* `null' may be assigned to any reference type */
12811       if (rhs == null_pointer_node)
12812         new_rhs = null_pointer_node;
12813       /* Try the reference assignment conversion */
12814       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12815         new_rhs = rhs;
12816       /* This is a magic assignment that we process differently */
12817       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12818         new_rhs = rhs;
12819     }
12820   return new_rhs;
12821 }
12822
12823 /* Check that RHS can be converted into LHS_TYPE by the assignment
12824    conversion (5.2), for the cases of RHS being a builtin type. Return
12825    NULL_TREE if the conversion fails or if because RHS isn't of a
12826    builtin type. Return a converted RHS if the conversion is possible.  */
12827
12828 static tree
12829 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12830 {
12831   tree new_rhs = NULL_TREE;
12832   tree rhs_type = TREE_TYPE (rhs);
12833
12834   /* Handle boolean specially.  */
12835   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12836       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12837     {
12838       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12839           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12840         new_rhs = rhs;
12841     }
12842
12843   /* 5.1.1 Try Identity Conversion,
12844      5.1.2 Try Widening Primitive Conversion */
12845   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12846     new_rhs = convert (lhs_type, rhs);
12847
12848   /* Try a narrowing primitive conversion (5.1.3):
12849        - expression is a constant expression of type byte, short, char,
12850          or int, AND
12851        - variable is byte, short or char AND
12852        - The value of the expression is representable in the type of the
12853          variable */
12854   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12855             || rhs_type == char_type_node || rhs_type == int_type_node)
12856             && TREE_CONSTANT (rhs)
12857            && (lhs_type == byte_type_node || lhs_type == char_type_node
12858                || lhs_type == short_type_node))
12859     {
12860       if (int_fits_type_p (rhs, lhs_type))
12861         new_rhs = convert (lhs_type, rhs);
12862       else if (wfl_op1)         /* Might be called with a NULL */
12863         parse_warning_context
12864           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12865            print_int_node (rhs), lang_printable_name (lhs_type, 0));
12866       /* Reported a warning that will turn into an error further
12867          down, so we don't return */
12868     }
12869
12870   return new_rhs;
12871 }
12872
12873 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12874    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12875    0 is the conversion test fails.  This implements parts the method
12876    invocation conversion (5.3).  */
12877
12878 static int
12879 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
12880 {
12881   /* 5.1.1: This is the identity conversion part. */
12882   if (lhs_type == rhs_type)
12883     return 1;
12884
12885   /* Reject non primitive types and boolean conversions.  */
12886   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12887     return 0;
12888
12889   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12890      than a char can't be converted into a char. Short can't too, but
12891      the < test below takes care of that */
12892   if (lhs_type == char_type_node && rhs_type == byte_type_node)
12893     return 0;
12894
12895   /* Accept all promoted type here. Note, we can't use <= in the test
12896      below, because we still need to bounce out assignments of short
12897      to char and the likes */
12898   if (lhs_type == int_type_node
12899       && (rhs_type == promoted_byte_type_node
12900           || rhs_type == promoted_short_type_node
12901           || rhs_type == promoted_char_type_node
12902           || rhs_type == promoted_boolean_type_node))
12903     return 1;
12904
12905   /* From here, an integral is widened if its precision is smaller
12906      than the precision of the LHS or if the LHS is a floating point
12907      type, or the RHS is a float and the RHS a double. */
12908   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12909        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12910       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12911       || (rhs_type == float_type_node && lhs_type == double_type_node))
12912     return 1;
12913
12914   return 0;
12915 }
12916
12917 /* Check that something of SOURCE type can be assigned or cast to
12918    something of DEST type at runtime. Return 1 if the operation is
12919    valid, 0 otherwise. If CAST is set to 1, we're treating the case
12920    were SOURCE is cast into DEST, which borrows a lot of the
12921    assignment check. */
12922
12923 static int
12924 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
12925 {
12926   /* SOURCE or DEST might be null if not from a declared entity. */
12927   if (!source || !dest)
12928     return 0;
12929   if (JNULLP_TYPE_P (source))
12930     return 1;
12931   if (TREE_CODE (source) == POINTER_TYPE)
12932     source = TREE_TYPE (source);
12933   if (TREE_CODE (dest) == POINTER_TYPE)
12934     dest = TREE_TYPE (dest);
12935
12936   /* If source and dest are being compiled from bytecode, they may need to
12937      be loaded. */
12938   if (CLASS_P (source) && !CLASS_LOADED_P (source))
12939     {
12940       load_class (source, 1);
12941       safe_layout_class (source);
12942     }
12943   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
12944     {
12945       load_class (dest, 1);
12946       safe_layout_class (dest);
12947     }
12948
12949   /* Case where SOURCE is a class type */
12950   if (TYPE_CLASS_P (source))
12951     {
12952       if (TYPE_CLASS_P (dest))
12953         return  (source == dest
12954                  || inherits_from_p (source, dest)
12955                  || (cast && inherits_from_p (dest, source)));
12956       if (TYPE_INTERFACE_P (dest))
12957         {
12958           /* If doing a cast and SOURCE is final, the operation is
12959              always correct a compile time (because even if SOURCE
12960              does not implement DEST, a subclass of SOURCE might). */
12961           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12962             return 1;
12963           /* Otherwise, SOURCE must implement DEST */
12964           return interface_of_p (dest, source);
12965         }
12966       /* DEST is an array, cast permitted if SOURCE is of Object type */
12967       return (cast && source == object_type_node ? 1 : 0);
12968     }
12969   if (TYPE_INTERFACE_P (source))
12970     {
12971       if (TYPE_CLASS_P (dest))
12972         {
12973           /* If not casting, DEST must be the Object type */
12974           if (!cast)
12975             return dest == object_type_node;
12976           /* We're doing a cast. The cast is always valid is class
12977              DEST is not final, otherwise, DEST must implement SOURCE */
12978           else if (!CLASS_FINAL (TYPE_NAME (dest)))
12979             return 1;
12980           else
12981             return interface_of_p (source, dest);
12982         }
12983       if (TYPE_INTERFACE_P (dest))
12984         {
12985           /* If doing a cast, then if SOURCE and DEST contain method
12986              with the same signature but different return type, then
12987              this is a (compile time) error */
12988           if (cast)
12989             {
12990               tree method_source, method_dest;
12991               tree source_type;
12992               tree source_sig;
12993               tree source_name;
12994               for (method_source = TYPE_METHODS (source); method_source;
12995                    method_source = TREE_CHAIN (method_source))
12996                 {
12997                   source_sig =
12998                     build_java_argument_signature (TREE_TYPE (method_source));
12999                   source_type = TREE_TYPE (TREE_TYPE (method_source));
13000                   source_name = DECL_NAME (method_source);
13001                   for (method_dest = TYPE_METHODS (dest);
13002                        method_dest; method_dest = TREE_CHAIN (method_dest))
13003                     if (source_sig ==
13004                         build_java_argument_signature (TREE_TYPE (method_dest))
13005                         && source_name == DECL_NAME (method_dest)
13006                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
13007                       return 0;
13008                 }
13009               return 1;
13010             }
13011           else
13012             return source == dest || interface_of_p (dest, source);
13013         }
13014       else
13015         {
13016           /* Array */
13017           return (cast
13018                   && (DECL_NAME (TYPE_NAME (source))
13019                       == java_lang_cloneable_identifier_node
13020                       || (DECL_NAME (TYPE_NAME (source))
13021                           == java_io_serializable_identifier_node)));
13022         }
13023     }
13024   if (TYPE_ARRAY_P (source))
13025     {
13026       if (TYPE_CLASS_P (dest))
13027         return dest == object_type_node;
13028       /* Can't cast an array to an interface unless the interface is
13029          java.lang.Cloneable or java.io.Serializable.  */
13030       if (TYPE_INTERFACE_P (dest))
13031         return (DECL_NAME (TYPE_NAME (dest))
13032                 == java_lang_cloneable_identifier_node
13033                 || (DECL_NAME (TYPE_NAME (dest))
13034                     == java_io_serializable_identifier_node));
13035       else                      /* Arrays */
13036         {
13037           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13038           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13039
13040           /* In case of severe errors, they turn out null */
13041           if (!dest_element_type || !source_element_type)
13042             return 0;
13043           if (source_element_type == dest_element_type)
13044             return 1;
13045           return valid_ref_assignconv_cast_p (source_element_type,
13046                                               dest_element_type, cast);
13047         }
13048       return 0;
13049     }
13050   return 0;
13051 }
13052
13053 static int
13054 valid_cast_to_p (tree source, tree dest)
13055 {
13056   if (TREE_CODE (source) == POINTER_TYPE)
13057     source = TREE_TYPE (source);
13058   if (TREE_CODE (dest) == POINTER_TYPE)
13059     dest = TREE_TYPE (dest);
13060
13061   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13062     return valid_ref_assignconv_cast_p (source, dest, 1);
13063
13064   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13065     return 1;
13066
13067   else if (TREE_CODE (source) == BOOLEAN_TYPE
13068            && TREE_CODE (dest) == BOOLEAN_TYPE)
13069     return 1;
13070
13071   return 0;
13072 }
13073
13074 static tree
13075 do_unary_numeric_promotion (tree arg)
13076 {
13077   tree type = TREE_TYPE (arg);
13078   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13079       || TREE_CODE (type) == CHAR_TYPE)
13080     arg = convert (int_type_node, arg);
13081   return arg;
13082 }
13083
13084 /* Return a nonzero value if SOURCE can be converted into DEST using
13085    the method invocation conversion rule (5.3).  */
13086 static int
13087 valid_method_invocation_conversion_p (tree dest, tree source)
13088 {
13089   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13090            && valid_builtin_assignconv_identity_widening_p (dest, source))
13091           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13092               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13093               && valid_ref_assignconv_cast_p (source, dest, 0)));
13094 }
13095
13096 /* Build an incomplete binop expression. */
13097
13098 static tree
13099 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13100 {
13101   tree binop = build (op, NULL_TREE, op1, op2);
13102   TREE_SIDE_EFFECTS (binop) = 1;
13103   /* Store the location of the operator, for better error report. The
13104      string of the operator will be rebuild based on the OP value. */
13105   EXPR_WFL_LINECOL (binop) = op_location;
13106   return binop;
13107 }
13108
13109 /* Build the string of the operator retained by NODE. If NODE is part
13110    of a compound expression, add an '=' at the end of the string. This
13111    function is called when an error needs to be reported on an
13112    operator. The string is returned as a pointer to a static character
13113    buffer. */
13114
13115 static char *
13116 operator_string (tree node)
13117 {
13118 #define BUILD_OPERATOR_STRING(S)                                        \
13119   {                                                                     \
13120     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13121     return buffer;                                                      \
13122   }
13123
13124   static char buffer [10];
13125   switch (TREE_CODE (node))
13126     {
13127     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13128     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13129     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13130     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13131     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13132     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13133     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13134     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13135     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13136     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13137     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13138     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13139     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13140     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13141     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13142     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13143     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13144     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13145     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13146     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13147     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13148     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13149     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13150     case PREINCREMENT_EXPR:     /* Fall through */
13151     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13152     case PREDECREMENT_EXPR:     /* Fall through */
13153     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13154     default:
13155       internal_error ("unregistered operator %s",
13156                       tree_code_name [TREE_CODE (node)]);
13157     }
13158   return NULL;
13159 #undef BUILD_OPERATOR_STRING
13160 }
13161
13162 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13163
13164 static int
13165 java_decl_equiv (tree var_acc1, tree var_acc2)
13166 {
13167   if (JDECL_P (var_acc1))
13168     return (var_acc1 == var_acc2);
13169
13170   return (TREE_CODE (var_acc1) == COMPONENT_REF
13171           && TREE_CODE (var_acc2) == COMPONENT_REF
13172           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13173              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13174           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13175 }
13176
13177 /* Return a nonzero value if CODE is one of the operators that can be
13178    used in conjunction with the `=' operator in a compound assignment.  */
13179
13180 static int
13181 binop_compound_p (enum tree_code code)
13182 {
13183   int i;
13184   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13185     if (binop_lookup [i] == code)
13186       break;
13187
13188   return i < BINOP_COMPOUND_CANDIDATES;
13189 }
13190
13191 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13192
13193 static tree
13194 java_refold (tree t)
13195 {
13196   tree c, b, ns, decl;
13197
13198   if (TREE_CODE (t) != MODIFY_EXPR)
13199     return t;
13200
13201   c = TREE_OPERAND (t, 1);
13202   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13203          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13204          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13205     return t;
13206
13207   /* Now the left branch of the binary operator. */
13208   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13209   if (! (b && TREE_CODE (b) == NOP_EXPR
13210          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13211     return t;
13212
13213   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13214   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13215          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13216     return t;
13217
13218   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13219   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13220       /* It's got to be the an equivalent decl */
13221       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13222     {
13223       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13224       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13225       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13226       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13227       /* Change the right part of the BINOP_EXPR */
13228       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13229     }
13230
13231   return t;
13232 }
13233
13234 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13235    errors but we modify NODE so that it contains the type computed
13236    according to the expression, when it's fixed. Otherwise, we write
13237    error_mark_node as the type. It allows us to further the analysis
13238    of remaining nodes and detects more errors in certain cases.  */
13239
13240 static tree
13241 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13242 {
13243   tree op1 = TREE_OPERAND (node, 0);
13244   tree op2 = TREE_OPERAND (node, 1);
13245   tree op1_type = TREE_TYPE (op1);
13246   tree op2_type = TREE_TYPE (op2);
13247   tree prom_type = NULL_TREE, cn;
13248   enum tree_code code = TREE_CODE (node);
13249
13250   /* If 1, tell the routine that we have to return error_mark_node
13251      after checking for the initialization of the RHS */
13252   int error_found = 0;
13253
13254   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13255
13256   /* If either op<n>_type are NULL, this might be early signs of an
13257      error situation, unless it's too early to tell (in case we're
13258      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13259      correctly so the error can be later on reported accurately. */
13260   if (! (code == PLUS_EXPR || code == NE_EXPR
13261          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13262     {
13263       tree n;
13264       if (! op1_type)
13265         {
13266           n = java_complete_tree (op1);
13267           op1_type = TREE_TYPE (n);
13268         }
13269       if (! op2_type)
13270         {
13271           n = java_complete_tree (op2);
13272           op2_type = TREE_TYPE (n);
13273         }
13274     }
13275
13276   switch (code)
13277     {
13278     /* 15.16 Multiplicative operators */
13279     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13280     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13281     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13282     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13283       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13284         {
13285           if (!JNUMERIC_TYPE_P (op1_type))
13286             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13287           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13288             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13289           TREE_TYPE (node) = error_mark_node;
13290           error_found = 1;
13291           break;
13292         }
13293       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13294
13295       /* Detect integral division by zero */
13296       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13297           && TREE_CODE (prom_type) == INTEGER_TYPE
13298           && (op2 == integer_zero_node || op2 == long_zero_node ||
13299               (TREE_CODE (op2) == INTEGER_CST &&
13300                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13301         {
13302           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13303           TREE_CONSTANT (node) = 0;
13304           TREE_INVARIANT (node) = 0;
13305         }
13306
13307       /* Change the division operator if necessary */
13308       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13309         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13310
13311       /* Before divisions as is disappear, try to simplify and bail if
13312          applicable, otherwise we won't perform even simple
13313          simplifications like (1-1)/3. We can't do that with floating
13314          point number, folds can't handle them at this stage. */
13315       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13316           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13317         {
13318           TREE_TYPE (node) = prom_type;
13319           node = fold (node);
13320           if (TREE_CODE (node) != code)
13321             return node;
13322         }
13323
13324       if (TREE_CODE (prom_type) == INTEGER_TYPE
13325           && flag_use_divide_subroutine
13326           && ! flag_emit_class_files
13327           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13328         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13329
13330       /* This one is more complicated. FLOATs are processed by a
13331          function call to soft_fmod. Duplicate the value of the
13332          COMPOUND_ASSIGN_P flag. */
13333       if (code == TRUNC_MOD_EXPR)
13334         {
13335           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13336           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13337           TREE_SIDE_EFFECTS (mod)
13338             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13339           return mod;
13340         }
13341       break;
13342
13343     /* 15.17 Additive Operators */
13344     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13345
13346       /* Operation is valid if either one argument is a string
13347          constant, a String object or a StringBuffer crafted for the
13348          purpose of the a previous usage of the String concatenation
13349          operator */
13350
13351       if (TREE_CODE (op1) == STRING_CST
13352           || TREE_CODE (op2) == STRING_CST
13353           || JSTRING_TYPE_P (op1_type)
13354           || JSTRING_TYPE_P (op2_type)
13355           || IS_CRAFTED_STRING_BUFFER_P (op1)
13356           || IS_CRAFTED_STRING_BUFFER_P (op2))
13357         return build_string_concatenation (op1, op2);
13358
13359     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13360                                    Numeric Types */
13361       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13362         {
13363           if (!JNUMERIC_TYPE_P (op1_type))
13364             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13365           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13366             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13367           TREE_TYPE (node) = error_mark_node;
13368           error_found = 1;
13369           break;
13370         }
13371       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13372       break;
13373
13374     /* 15.18 Shift Operators */
13375     case LSHIFT_EXPR:
13376     case RSHIFT_EXPR:
13377     case URSHIFT_EXPR:
13378       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13379         {
13380           if (!JINTEGRAL_TYPE_P (op1_type))
13381             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13382           else
13383             {
13384               if (JNUMERIC_TYPE_P (op2_type))
13385                 parse_error_context (wfl_operator,
13386                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13387                                      operator_string (node),
13388                                      lang_printable_name (op2_type, 0));
13389               else
13390                 parse_error_context (wfl_operator,
13391                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13392                                      operator_string (node),
13393                                      lang_printable_name (op2_type, 0));
13394             }
13395           TREE_TYPE (node) = error_mark_node;
13396           error_found = 1;
13397           break;
13398         }
13399
13400       /* Unary numeric promotion (5.6.1) is performed on each operand
13401          separately */
13402       op1 = do_unary_numeric_promotion (op1);
13403       op2 = do_unary_numeric_promotion (op2);
13404
13405       /* If the right hand side is of type `long', first cast it to
13406          `int'.  */
13407       if (TREE_TYPE (op2) == long_type_node)
13408         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13409
13410       /* The type of the shift expression is the type of the promoted
13411          type of the left-hand operand */
13412       prom_type = TREE_TYPE (op1);
13413
13414       /* Shift int only up to 0x1f and long up to 0x3f */
13415       if (prom_type == int_type_node)
13416         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13417                            build_int_2 (0x1f, 0)));
13418       else
13419         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13420                            build_int_2 (0x3f, 0)));
13421
13422       /* The >>> operator is a >> operating on unsigned quantities */
13423       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13424         {
13425           tree to_return;
13426           tree utype = java_unsigned_type (prom_type);
13427           op1 = convert (utype, op1);
13428           TREE_SET_CODE (node, RSHIFT_EXPR);
13429           TREE_OPERAND (node, 0) = op1;
13430           TREE_OPERAND (node, 1) = op2;
13431           TREE_TYPE (node) = utype;
13432           to_return = convert (prom_type, node);
13433           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13434           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13435           TREE_SIDE_EFFECTS (to_return)
13436             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13437           return to_return;
13438         }
13439       break;
13440
13441       /* 15.19.1 Type Comparison Operator instanceof */
13442     case INSTANCEOF_EXPR:
13443
13444       TREE_TYPE (node) = boolean_type_node;
13445
13446       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13447       if ((cn = patch_string (op1)))
13448         {
13449           op1 = cn;
13450           op1_type = TREE_TYPE (op1);
13451         }
13452       if (op1_type == NULL_TREE)
13453         abort ();
13454
13455       if (!(op2_type = resolve_type_during_patch (op2)))
13456         return error_mark_node;
13457
13458       /* The first operand must be a reference type or the null type */
13459       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13460         error_found = 1;        /* Error reported further below */
13461
13462       /* The second operand must be a reference type */
13463       if (!JREFERENCE_TYPE_P (op2_type))
13464         {
13465           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13466           parse_error_context
13467             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13468              lang_printable_name (op2_type, 0));
13469           error_found = 1;
13470         }
13471
13472       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13473         {
13474           /* If the first operand is null, the result is always false */
13475           if (op1 == null_pointer_node)
13476             return boolean_false_node;
13477           else if (flag_emit_class_files)
13478             {
13479               TREE_OPERAND (node, 1) = op2_type;
13480               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13481               return node;
13482             }
13483           /* Otherwise we have to invoke instance of to figure it out */
13484           else
13485             return build_instanceof (op1, op2_type);
13486         }
13487       /* There is no way the expression operand can be an instance of
13488          the type operand. This is a compile time error. */
13489       else
13490         {
13491           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13492           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13493           parse_error_context
13494             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13495              t1, lang_printable_name (op2_type, 0));
13496           free (t1);
13497           error_found = 1;
13498         }
13499
13500       break;
13501
13502       /* 15.21 Bitwise and Logical Operators */
13503     case BIT_AND_EXPR:
13504     case BIT_XOR_EXPR:
13505     case BIT_IOR_EXPR:
13506       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13507         /* Binary numeric promotion is performed on both operand and the
13508            expression retain that type */
13509         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13510
13511       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13512                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13513         /* The type of the bitwise operator expression is BOOLEAN */
13514         prom_type = boolean_type_node;
13515       else
13516         {
13517           if (!JINTEGRAL_TYPE_P (op1_type))
13518             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13519           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13520             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13521           TREE_TYPE (node) = error_mark_node;
13522           error_found = 1;
13523           /* Insert a break here if adding thing before the switch's
13524              break for this case */
13525         }
13526       break;
13527
13528       /* 15.22 Conditional-And Operator */
13529     case TRUTH_ANDIF_EXPR:
13530       /* 15.23 Conditional-Or Operator */
13531     case TRUTH_ORIF_EXPR:
13532       /* Operands must be of BOOLEAN type */
13533       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13534           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13535         {
13536           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13537             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13538           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13539             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13540           TREE_TYPE (node) = boolean_type_node;
13541           error_found = 1;
13542           break;
13543         }
13544       else if (integer_zerop (op1))
13545         {
13546           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13547         }
13548       else if (integer_onep (op1))
13549         {
13550           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13551         }
13552       /* The type of the conditional operators is BOOLEAN */
13553       prom_type = boolean_type_node;
13554       break;
13555
13556       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13557     case LT_EXPR:
13558     case GT_EXPR:
13559     case LE_EXPR:
13560     case GE_EXPR:
13561       /* The type of each of the operands must be a primitive numeric
13562          type */
13563       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13564         {
13565           if (!JNUMERIC_TYPE_P (op1_type))
13566             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13567           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13568             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13569           TREE_TYPE (node) = boolean_type_node;
13570           error_found = 1;
13571           break;
13572         }
13573       /* Binary numeric promotion is performed on the operands */
13574       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13575       /* The type of the relation expression is always BOOLEAN */
13576       prom_type = boolean_type_node;
13577       break;
13578
13579       /* 15.20 Equality Operator */
13580     case EQ_EXPR:
13581     case NE_EXPR:
13582       /* It's time for us to patch the strings. */
13583       if ((cn = patch_string (op1)))
13584        {
13585          op1 = cn;
13586          op1_type = TREE_TYPE (op1);
13587        }
13588       if ((cn = patch_string (op2)))
13589        {
13590          op2 = cn;
13591          op2_type = TREE_TYPE (op2);
13592        }
13593
13594       /* 15.20.1 Numerical Equality Operators == and != */
13595       /* Binary numeric promotion is performed on the operands */
13596       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13597         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13598
13599       /* 15.20.2 Boolean Equality Operators == and != */
13600       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13601           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13602         ;                       /* Nothing to do here */
13603
13604       /* 15.20.3 Reference Equality Operators == and != */
13605       /* Types have to be either references or the null type. If
13606          they're references, it must be possible to convert either
13607          type to the other by casting conversion. */
13608       else if (op1 == null_pointer_node || op2 == null_pointer_node
13609                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13610                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13611                        || valid_ref_assignconv_cast_p (op2_type,
13612                                                        op1_type, 1))))
13613         ;                       /* Nothing to do here */
13614
13615       /* Else we have an error figure what can't be converted into
13616          what and report the error */
13617       else
13618         {
13619           char *t1;
13620           t1 = xstrdup (lang_printable_name (op1_type, 0));
13621           parse_error_context
13622             (wfl_operator,
13623              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13624              operator_string (node), t1,
13625              lang_printable_name (op2_type, 0));
13626           free (t1);
13627           TREE_TYPE (node) = boolean_type_node;
13628           error_found = 1;
13629           break;
13630         }
13631       prom_type = boolean_type_node;
13632       break;
13633     default:
13634       abort ();
13635     }
13636
13637   if (error_found)
13638     return error_mark_node;
13639
13640   TREE_OPERAND (node, 0) = op1;
13641   TREE_OPERAND (node, 1) = op2;
13642   TREE_TYPE (node) = prom_type;
13643   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13644
13645   if (flag_emit_xref)
13646     return node;
13647
13648   /* fold does not respect side-effect order as required for Java but not C.
13649    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13650    * bytecode.
13651    */
13652   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13653       : ! TREE_SIDE_EFFECTS (node))
13654     node = fold (node);
13655   return node;
13656 }
13657
13658 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13659    zero value, the value of CSTE comes after the valude of STRING */
13660
13661 static tree
13662 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13663 {
13664   const char *old = TREE_STRING_POINTER (cste);
13665   int old_len = TREE_STRING_LENGTH (cste);
13666   int len = old_len + string_len;
13667   char *new = alloca (len+1);
13668
13669   if (after)
13670     {
13671       memcpy (new, string, string_len);
13672       memcpy (&new [string_len], old, old_len);
13673     }
13674   else
13675     {
13676       memcpy (new, old, old_len);
13677       memcpy (&new [old_len], string, string_len);
13678     }
13679   new [len] = '\0';
13680   return build_string (len, new);
13681 }
13682
13683 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13684    new STRING_CST on success, NULL_TREE on failure.  */
13685
13686 static tree
13687 merge_string_cste (tree op1, tree op2, int after)
13688 {
13689   /* Handle two string constants right away.  */
13690   if (TREE_CODE (op2) == STRING_CST)
13691     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13692                                  TREE_STRING_LENGTH (op2), after);
13693
13694   /* Reasonable integer constant can be treated right away.  */
13695   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13696     {
13697       static const char *const boolean_true = "true";
13698       static const char *const boolean_false = "false";
13699       static const char *const null_pointer = "null";
13700       char ch[4];
13701       const char *string;
13702
13703       if (op2 == boolean_true_node)
13704         string = boolean_true;
13705       else if (op2 == boolean_false_node)
13706         string = boolean_false;
13707       else if (op2 == null_pointer_node
13708                || (integer_zerop (op2)
13709                    && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
13710         /* FIXME: null is not a compile-time constant, so it is only safe to
13711            merge if the overall expression is non-constant. However, this
13712            code always merges without checking the overall expression.  */
13713         string = null_pointer;
13714       else if (TREE_TYPE (op2) == char_type_node)
13715         {
13716           /* Convert the character into UTF-8.  */
13717           unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13718           unsigned char *p = (unsigned char *) ch;
13719           if (0x01 <= c && c <= 0x7f)
13720             *p++ = (unsigned char) c;
13721           else if (c < 0x7ff)
13722             {
13723               *p++ = (unsigned char) (c >> 6 | 0xc0);
13724               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13725             }
13726           else
13727             {
13728               *p++ = (unsigned char) (c >> 12 | 0xe0);
13729               *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13730               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13731             }
13732           *p = '\0';
13733
13734           string = ch;
13735         }
13736       else
13737         string = string_convert_int_cst (op2);
13738
13739       return do_merge_string_cste (op1, string, strlen (string), after);
13740     }
13741   return NULL_TREE;
13742 }
13743
13744 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13745    has to be a STRING_CST and the other part must be a STRING_CST or a
13746    INTEGRAL constant. Return a new STRING_CST if the operation
13747    succeed, NULL_TREE otherwise.
13748
13749    If the case we want to optimize for space, we might want to return
13750    NULL_TREE for each invocation of this routine. FIXME */
13751
13752 static tree
13753 string_constant_concatenation (tree op1, tree op2)
13754 {
13755   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13756     {
13757       tree string, rest;
13758       int invert;
13759
13760       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13761       rest   = (string == op1 ? op2 : op1);
13762       invert = (string == op1 ? 0 : 1 );
13763
13764       /* Walk REST, only if it looks reasonable */
13765       if (TREE_CODE (rest) != STRING_CST
13766           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13767           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13768           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13769         {
13770           rest = java_complete_tree (rest);
13771           if (rest == error_mark_node)
13772             return error_mark_node;
13773           rest = fold (rest);
13774         }
13775       return merge_string_cste (string, rest, invert);
13776     }
13777   return NULL_TREE;
13778 }
13779
13780 /* Implement the `+' operator. Does static optimization if possible,
13781    otherwise create (if necessary) and append elements to a
13782    StringBuffer. The StringBuffer will be carried around until it is
13783    used for a function call or an assignment. Then toString() will be
13784    called on it to turn it into a String object. */
13785
13786 static tree
13787 build_string_concatenation (tree op1, tree op2)
13788 {
13789   tree result;
13790   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13791
13792   if (flag_emit_xref)
13793     return build (PLUS_EXPR, string_type_node, op1, op2);
13794
13795   /* Try to do some static optimization */
13796   if ((result = string_constant_concatenation (op1, op2)))
13797     return result;
13798
13799   /* Discard empty strings on either side of the expression */
13800   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13801     {
13802       op1 = op2;
13803       op2 = NULL_TREE;
13804     }
13805   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13806     op2 = NULL_TREE;
13807
13808   /* If operands are string constant, turn then into object references */
13809   if (TREE_CODE (op1) == STRING_CST)
13810     op1 = patch_string_cst (op1);
13811   if (op2 && TREE_CODE (op2) == STRING_CST)
13812     op2 = patch_string_cst (op2);
13813
13814   /* If either one of the constant is null and the other non null
13815      operand is a String constant, return it. */
13816   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13817     return op1;
13818
13819   /* If OP1 isn't already a StringBuffer, create and
13820      initialize a new one */
13821   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13822     {
13823       /* Two solutions here:
13824          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13825          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13826       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13827         op1 = BUILD_STRING_BUFFER (op1);
13828       else
13829         {
13830           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13831           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13832         }
13833     }
13834
13835   if (op2)
13836     {
13837       /* OP1 is no longer the last node holding a crafted StringBuffer */
13838       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13839       /* Create a node for `{new...,xxx}.append (op2)' */
13840       if (op2)
13841         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13842     }
13843
13844   /* Mark the last node holding a crafted StringBuffer */
13845   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13846
13847   TREE_SIDE_EFFECTS (op1) = side_effects;
13848   return op1;
13849 }
13850
13851 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13852    StringBuffer. If no string were found to be patched, return
13853    NULL. */
13854
13855 static tree
13856 patch_string (tree node)
13857 {
13858   if (node == error_mark_node)
13859     return error_mark_node;
13860   if (TREE_CODE (node) == STRING_CST)
13861     return patch_string_cst (node);
13862   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13863     {
13864       int saved = ctxp->explicit_constructor_p;
13865       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13866       tree ret;
13867       /* Temporary disable forbid the use of `this'. */
13868       ctxp->explicit_constructor_p = 0;
13869       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13870       /* String concatenation arguments must be evaluated in order too. */
13871       ret = force_evaluation_order (ret);
13872       /* Restore it at its previous value */
13873       ctxp->explicit_constructor_p = saved;
13874       return ret;
13875     }
13876   return NULL_TREE;
13877 }
13878
13879 /* Build the internal representation of a string constant.  */
13880
13881 static tree
13882 patch_string_cst (tree node)
13883 {
13884   int location;
13885   if (! flag_emit_class_files)
13886     {
13887       node = get_identifier (TREE_STRING_POINTER (node));
13888       location = alloc_name_constant (CONSTANT_String, node);
13889       node = build_ref_from_constant_pool (location);
13890     }
13891   TREE_CONSTANT (node) = 1;
13892   TREE_INVARIANT (node) = 1;
13893
13894   /* ??? Guessing that the class file code can't handle casts.  */
13895   if (! flag_emit_class_files)
13896     node = convert (string_ptr_type_node, node);
13897   else
13898     TREE_TYPE (node) = string_ptr_type_node;
13899
13900   return node;
13901 }
13902
13903 /* Build an incomplete unary operator expression. */
13904
13905 static tree
13906 build_unaryop (int op_token, int op_location, tree op1)
13907 {
13908   enum tree_code op;
13909   tree unaryop;
13910   switch (op_token)
13911     {
13912     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13913     case MINUS_TK: op = NEGATE_EXPR; break;
13914     case NEG_TK: op = TRUTH_NOT_EXPR; break;
13915     case NOT_TK: op = BIT_NOT_EXPR; break;
13916     default: abort ();
13917     }
13918
13919   unaryop = build1 (op, NULL_TREE, op1);
13920   TREE_SIDE_EFFECTS (unaryop) = 1;
13921   /* Store the location of the operator, for better error report. The
13922      string of the operator will be rebuild based on the OP value. */
13923   EXPR_WFL_LINECOL (unaryop) = op_location;
13924   return unaryop;
13925 }
13926
13927 /* Special case for the ++/-- operators, since they require an extra
13928    argument to build, which is set to NULL and patched
13929    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
13930
13931 static tree
13932 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
13933 {
13934   static const enum tree_code lookup [2][2] =
13935     {
13936       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
13937       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
13938     };
13939   tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
13940                      NULL_TREE, op1, NULL_TREE);
13941   TREE_SIDE_EFFECTS (node) = 1;
13942   /* Store the location of the operator, for better error report. The
13943      string of the operator will be rebuild based on the OP value. */
13944   EXPR_WFL_LINECOL (node) = op_location;
13945   return node;
13946 }
13947
13948 /* Build an incomplete cast operator, based on the use of the
13949    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13950    set. java_complete_tree is trained to walk a CONVERT_EXPR even
13951    though its type is already set.  */
13952
13953 static tree
13954 build_cast (int location, tree type, tree exp)
13955 {
13956   tree node = build1 (CONVERT_EXPR, type, exp);
13957   EXPR_WFL_LINECOL (node) = location;
13958   return node;
13959 }
13960
13961 /* Build an incomplete class reference operator.  */
13962 static tree
13963 build_incomplete_class_ref (int location, tree class_name)
13964 {
13965   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13966   tree class_decl = GET_CPC ();
13967   tree this_class = TREE_TYPE (class_decl);
13968
13969   /* Generate the synthetic static method `class$'.  (Previously we
13970      deferred this, causing different method tables to be emitted
13971      for native code and bytecode.)  */
13972   if (!TYPE_DOT_CLASS (this_class)
13973       && !JPRIMITIVE_TYPE_P (class_name)
13974       && !(TREE_CODE (class_name) == VOID_TYPE))
13975     {
13976       tree cpc_list = GET_CPC_LIST();
13977       tree cpc = cpc_list;
13978       tree target_class;
13979
13980       /* For inner classes, add a 'class$' method to their outermost
13981          context, creating it if necessary.  */
13982
13983       while (GET_NEXT_ENCLOSING_CPC(cpc))
13984         cpc = GET_NEXT_ENCLOSING_CPC(cpc);
13985       class_decl = TREE_VALUE (cpc);
13986
13987       target_class = TREE_TYPE (class_decl);
13988
13989       if (CLASS_INTERFACE (TYPE_NAME (target_class)))
13990         {
13991           /* For interfaces, adding a static 'class$' method directly
13992              is illegal.  So create an inner class to contain the new
13993              method.  Empirically this matches the behavior of javac.  */
13994           tree t, inner;
13995           /* We want the generated inner class inside the outermost class. */
13996           GET_CPC_LIST() = cpc;
13997           t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
13998           inner = create_anonymous_class (0, t);
13999           target_class = TREE_TYPE (inner);
14000           end_class_declaration (1);
14001           GET_CPC_LIST() = cpc_list;
14002         }
14003
14004       if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
14005         build_dot_class_method (target_class);
14006
14007       if (this_class != target_class)
14008         TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
14009     }
14010
14011   EXPR_WFL_LINECOL (node) = location;
14012   return node;
14013 }
14014
14015 /* Complete an incomplete class reference operator.  */
14016 static tree
14017 patch_incomplete_class_ref (tree node)
14018 {
14019   tree type = TREE_OPERAND (node, 0);
14020   tree ref_type;
14021
14022   if (!(ref_type = resolve_type_during_patch (type)))
14023     return error_mark_node;
14024
14025   /* If we're not emitting class files and we know ref_type is a
14026      compiled class, build a direct reference.  */
14027   if ((! flag_emit_class_files && is_compiled_class (ref_type))
14028       || JPRIMITIVE_TYPE_P (ref_type)
14029       || TREE_CODE (ref_type) == VOID_TYPE)
14030     {
14031       tree dot = build_class_ref (ref_type);
14032       /* A class referenced by `foo.class' is initialized.  */
14033       if (!flag_emit_class_files)
14034        dot = build_class_init (ref_type, dot);
14035       return java_complete_tree (dot);
14036     }
14037
14038   /* If we're emitting class files and we have to deal with non
14039      primitive types, we invoke the synthetic static method `class$'.  */
14040   ref_type = build_dot_class_method_invocation (current_class, ref_type);
14041   return java_complete_tree (ref_type);
14042 }
14043
14044 /* 15.14 Unary operators. We return error_mark_node in case of error,
14045    but preserve the type of NODE if the type is fixed.  */
14046
14047 static tree
14048 patch_unaryop (tree node, tree wfl_op)
14049 {
14050   tree op = TREE_OPERAND (node, 0);
14051   tree op_type = TREE_TYPE (op);
14052   tree prom_type = NULL_TREE, value, decl;
14053   int outer_field_flag = 0;
14054   int code = TREE_CODE (node);
14055   int error_found = 0;
14056
14057   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14058
14059   switch (code)
14060     {
14061       /* 15.13.2 Postfix Increment Operator ++ */
14062     case POSTINCREMENT_EXPR:
14063       /* 15.13.3 Postfix Increment Operator -- */
14064     case POSTDECREMENT_EXPR:
14065       /* 15.14.1 Prefix Increment Operator ++ */
14066     case PREINCREMENT_EXPR:
14067       /* 15.14.2 Prefix Decrement Operator -- */
14068     case PREDECREMENT_EXPR:
14069       op = decl = strip_out_static_field_access_decl (op);
14070       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14071       /* We might be trying to change an outer field accessed using
14072          access method. */
14073       if (outer_field_flag)
14074         {
14075           /* Retrieve the decl of the field we're trying to access. We
14076              do that by first retrieving the function we would call to
14077              access the field. It has been already verified that this
14078              field isn't final */
14079           if (flag_emit_class_files)
14080             decl = TREE_OPERAND (op, 0);
14081           else
14082             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14083           decl = DECL_FUNCTION_ACCESS_DECL (decl);
14084         }
14085       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14086       else if (!JDECL_P (decl)
14087           && TREE_CODE (decl) != COMPONENT_REF
14088           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14089           && TREE_CODE (decl) != INDIRECT_REF
14090           && !(TREE_CODE (decl) == COMPOUND_EXPR
14091                && TREE_OPERAND (decl, 1)
14092                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14093         {
14094           TREE_TYPE (node) = error_mark_node;
14095           error_found = 1;
14096         }
14097
14098       /* From now on, we know that op if a variable and that it has a
14099          valid wfl. We use wfl_op to locate errors related to the
14100          ++/-- operand. */
14101       if (!JNUMERIC_TYPE_P (op_type))
14102         {
14103           parse_error_context
14104             (wfl_op, "Invalid argument type `%s' to `%s'",
14105              lang_printable_name (op_type, 0), operator_string (node));
14106           TREE_TYPE (node) = error_mark_node;
14107           error_found = 1;
14108         }
14109       else
14110         {
14111           /* Before the addition, binary numeric promotion is performed on
14112              both operands, if really necessary */
14113           if (JINTEGRAL_TYPE_P (op_type))
14114             {
14115               value = build_int_2 (1, 0);
14116               TREE_TYPE (value) = TREE_TYPE (node) = op_type;
14117             }
14118           else
14119             {
14120               value = build_int_2 (1, 0);
14121               TREE_TYPE (node) =
14122                 binary_numeric_promotion (op_type,
14123                                           TREE_TYPE (value), &op, &value);
14124             }
14125
14126           /* We remember we might be accessing an outer field */
14127           if (outer_field_flag)
14128             {
14129               /* We re-generate an access to the field */
14130               value = build (PLUS_EXPR, TREE_TYPE (op),
14131                              build_outer_field_access (wfl_op, decl), value);
14132
14133               /* And we patch the original access$() into a write
14134                  with plus_op as a rhs */
14135               return outer_field_access_fix (node, op, value);
14136             }
14137
14138           /* And write back into the node. */
14139           TREE_OPERAND (node, 0) = op;
14140           TREE_OPERAND (node, 1) = value;
14141           /* Convert the overall back into its original type, if
14142              necessary, and return */
14143           if (JINTEGRAL_TYPE_P (op_type))
14144             return fold (node);
14145           else
14146             return fold (convert (op_type, node));
14147         }
14148       break;
14149
14150       /* 15.14.3 Unary Plus Operator + */
14151     case UNARY_PLUS_EXPR:
14152       /* 15.14.4 Unary Minus Operator - */
14153     case NEGATE_EXPR:
14154       if (!JNUMERIC_TYPE_P (op_type))
14155         {
14156           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14157           TREE_TYPE (node) = error_mark_node;
14158           error_found = 1;
14159         }
14160       /* Unary numeric promotion is performed on operand */
14161       else
14162         {
14163           op = do_unary_numeric_promotion (op);
14164           prom_type = TREE_TYPE (op);
14165           if (code == UNARY_PLUS_EXPR)
14166             return fold (op);
14167         }
14168       break;
14169
14170       /* 15.14.5 Bitwise Complement Operator ~ */
14171     case BIT_NOT_EXPR:
14172       if (!JINTEGRAL_TYPE_P (op_type))
14173         {
14174           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14175           TREE_TYPE (node) = error_mark_node;
14176           error_found = 1;
14177         }
14178       else
14179         {
14180           op = do_unary_numeric_promotion (op);
14181           prom_type = TREE_TYPE (op);
14182         }
14183       break;
14184
14185       /* 15.14.6 Logical Complement Operator ! */
14186     case TRUTH_NOT_EXPR:
14187       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14188         {
14189           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14190           /* But the type is known. We will report an error if further
14191              attempt of a assignment is made with this rhs */
14192           TREE_TYPE (node) = boolean_type_node;
14193           error_found = 1;
14194         }
14195       else
14196         prom_type = boolean_type_node;
14197       break;
14198
14199       /* 15.15 Cast Expression */
14200     case CONVERT_EXPR:
14201       value = patch_cast (node, wfl_operator);
14202       if (value == error_mark_node)
14203         {
14204           /* If this cast is part of an assignment, we tell the code
14205              that deals with it not to complain about a mismatch,
14206              because things have been cast, anyways */
14207           TREE_TYPE (node) = error_mark_node;
14208           error_found = 1;
14209         }
14210       else
14211         {
14212           value = fold (value);
14213           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14214           return value;
14215         }
14216       break;
14217     }
14218
14219   if (error_found)
14220     return error_mark_node;
14221
14222   /* There are cases where node has been replaced by something else
14223      and we don't end up returning here: UNARY_PLUS_EXPR,
14224      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14225   TREE_OPERAND (node, 0) = fold (op);
14226   TREE_TYPE (node) = prom_type;
14227   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14228   return fold (node);
14229 }
14230
14231 /* Generic type resolution that sometimes takes place during node
14232    patching. Returned the resolved type or generate an error
14233    message. Return the resolved type or NULL_TREE.  */
14234
14235 static tree
14236 resolve_type_during_patch (tree type)
14237 {
14238   if (unresolved_type_p (type, NULL))
14239     {
14240       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14241       if (!type_decl)
14242         {
14243           parse_error_context (type,
14244                                "Class `%s' not found in type declaration",
14245                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14246           return NULL_TREE;
14247         }
14248
14249       check_deprecation (type, type_decl);
14250
14251       return TREE_TYPE (type_decl);
14252     }
14253   return type;
14254 }
14255
14256 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14257    found. Otherwise NODE or something meant to replace it is returned.  */
14258
14259 static tree
14260 patch_cast (tree node, tree wfl_op)
14261 {
14262   tree op = TREE_OPERAND (node, 0);
14263   tree cast_type = TREE_TYPE (node);
14264   tree patched, op_type;
14265   char *t1;
14266
14267   /* Some string patching might be necessary at this stage */
14268   if ((patched = patch_string (op)))
14269     TREE_OPERAND (node, 0) = op = patched;
14270   op_type = TREE_TYPE (op);
14271
14272   /* First resolve OP_TYPE if unresolved */
14273   if (!(cast_type = resolve_type_during_patch (cast_type)))
14274     return error_mark_node;
14275
14276   /* Check on cast that are proven correct at compile time */
14277   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14278     {
14279       /* Same type */
14280       if (cast_type == op_type)
14281         return node;
14282
14283       /* A narrowing conversion from a floating-point number to an
14284          integral type requires special handling (5.1.3).  */
14285       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14286         if (cast_type != long_type_node)
14287           op = convert (integer_type_node, op);
14288
14289       /* Try widening/narrowing conversion.  Potentially, things need
14290          to be worked out in gcc so we implement the extreme cases
14291          correctly.  fold_convert() needs to be fixed.  */
14292       return convert (cast_type, op);
14293     }
14294
14295   /* It's also valid to cast a boolean into a boolean */
14296   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14297     return node;
14298
14299   /* null can be casted to references */
14300   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14301     return build_null_of_type (cast_type);
14302
14303   /* The remaining legal casts involve conversion between reference
14304      types. Check for their compile time correctness. */
14305   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14306       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14307     {
14308       TREE_TYPE (node) = promote_type (cast_type);
14309       /* Now, the case can be determined correct at compile time if
14310          OP_TYPE can be converted into CAST_TYPE by assignment
14311          conversion (5.2) */
14312
14313       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14314         {
14315           TREE_SET_CODE (node, NOP_EXPR);
14316           return node;
14317         }
14318
14319       if (flag_emit_class_files)
14320         {
14321           TREE_SET_CODE (node, CONVERT_EXPR);
14322           return node;
14323         }
14324
14325       /* The cast requires a run-time check */
14326       return build (CALL_EXPR, promote_type (cast_type),
14327                     build_address_of (soft_checkcast_node),
14328                     tree_cons (NULL_TREE, build_class_ref (cast_type),
14329                                build_tree_list (NULL_TREE, op)),
14330                     NULL_TREE);
14331     }
14332
14333   /* Any other casts are proven incorrect at compile time */
14334   t1 = xstrdup (lang_printable_name (op_type, 0));
14335   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14336                        t1, lang_printable_name (cast_type, 0));
14337   free (t1);
14338   return error_mark_node;
14339 }
14340
14341 /* Build a null constant and give it the type TYPE.  */
14342
14343 static tree
14344 build_null_of_type (tree type)
14345 {
14346   tree node = build_int_2 (0, 0);
14347   TREE_TYPE (node) = promote_type (type);
14348   return node;
14349 }
14350
14351 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14352    a list of indices. */
14353 static tree
14354 build_array_ref (int location, tree array, tree index)
14355 {
14356   tree node = build (ARRAY_REF, NULL_TREE, array, index, NULL_TREE, NULL_TREE);
14357   EXPR_WFL_LINECOL (node) = location;
14358   return node;
14359 }
14360
14361 /* 15.12 Array Access Expression */
14362
14363 static tree
14364 patch_array_ref (tree node)
14365 {
14366   tree array = TREE_OPERAND (node, 0);
14367   tree array_type  = TREE_TYPE (array);
14368   tree index = TREE_OPERAND (node, 1);
14369   tree index_type = TREE_TYPE (index);
14370   int error_found = 0;
14371
14372   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14373
14374   if (TREE_CODE (array_type) == POINTER_TYPE)
14375     array_type = TREE_TYPE (array_type);
14376
14377   /* The array reference must be an array */
14378   if (!TYPE_ARRAY_P (array_type))
14379     {
14380       parse_error_context
14381         (wfl_operator,
14382          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14383          lang_printable_name (array_type, 0));
14384       TREE_TYPE (node) = error_mark_node;
14385       error_found = 1;
14386     }
14387
14388   /* The array index undergoes unary numeric promotion. The promoted
14389      type must be int */
14390   index = do_unary_numeric_promotion (index);
14391   if (TREE_TYPE (index) != int_type_node)
14392     {
14393       if (valid_cast_to_p (index_type, int_type_node))
14394         parse_error_context (wfl_operator,
14395    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14396                              lang_printable_name (index_type, 0));
14397       else
14398         parse_error_context (wfl_operator,
14399           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14400                              lang_printable_name (index_type, 0));
14401       TREE_TYPE (node) = error_mark_node;
14402       error_found = 1;
14403     }
14404
14405   if (error_found)
14406     return error_mark_node;
14407
14408   array_type = TYPE_ARRAY_ELEMENT (array_type);
14409
14410   if (flag_emit_class_files || flag_emit_xref)
14411     {
14412       TREE_OPERAND (node, 0) = array;
14413       TREE_OPERAND (node, 1) = index;
14414     }
14415   else
14416     node = build_java_arrayaccess (array, array_type, index);
14417   TREE_TYPE (node) = array_type;
14418   return node;
14419 }
14420
14421 /* 15.9 Array Creation Expressions */
14422
14423 static tree
14424 build_newarray_node (tree type, tree dims, int extra_dims)
14425 {
14426   tree node =
14427     build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
14428            build_int_2 (extra_dims, 0));
14429   return node;
14430 }
14431
14432 static tree
14433 patch_newarray (tree node)
14434 {
14435   tree type = TREE_OPERAND (node, 0);
14436   tree dims = TREE_OPERAND (node, 1);
14437   tree cdim, array_type;
14438   int error_found = 0;
14439   int ndims = 0;
14440   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14441
14442   /* Dimension types are verified. It's better for the types to be
14443      verified in order. */
14444   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14445     {
14446       int dim_error = 0;
14447       tree dim = TREE_VALUE (cdim);
14448
14449       /* Dim might have been saved during its evaluation */
14450       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14451
14452       /* The type of each specified dimension must be an integral type. */
14453       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14454         dim_error = 1;
14455
14456       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14457          promoted type must be int. */
14458       else
14459         {
14460           dim = do_unary_numeric_promotion (dim);
14461           if (TREE_TYPE (dim) != int_type_node)
14462             dim_error = 1;
14463         }
14464
14465       /* Report errors on types here */
14466       if (dim_error)
14467         {
14468           parse_error_context
14469             (TREE_PURPOSE (cdim),
14470              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14471              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14472               "Explicit cast needed to" : "Can't"),
14473              lang_printable_name (TREE_TYPE (dim), 0));
14474           error_found = 1;
14475         }
14476
14477       TREE_PURPOSE (cdim) = NULL_TREE;
14478     }
14479
14480   /* Resolve array base type if unresolved */
14481   if (!(type = resolve_type_during_patch (type)))
14482     error_found = 1;
14483
14484   if (error_found)
14485     {
14486       /* We don't want further evaluation of this bogus array creation
14487          operation */
14488       TREE_TYPE (node) = error_mark_node;
14489       return error_mark_node;
14490     }
14491
14492   /* Set array_type to the actual (promoted) array type of the result. */
14493   if (TREE_CODE (type) == RECORD_TYPE)
14494     type = build_pointer_type (type);
14495   while (--xdims >= 0)
14496     {
14497       type = promote_type (build_java_array_type (type, -1));
14498     }
14499   dims = nreverse (dims);
14500   array_type = type;
14501   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14502     {
14503       type = array_type;
14504       array_type
14505         = build_java_array_type (type,
14506                                  TREE_CODE (cdim) == INTEGER_CST
14507                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14508                                  : -1);
14509       array_type = promote_type (array_type);
14510     }
14511   dims = nreverse (dims);
14512
14513   /* The node is transformed into a function call. Things are done
14514      differently according to the number of dimensions. If the number
14515      of dimension is equal to 1, then the nature of the base type
14516      (primitive or not) matters. */
14517   if (ndims == 1)
14518     return build_new_array (type, TREE_VALUE (dims));
14519
14520   /* Can't reuse what's already written in expr.c because it uses the
14521      JVM stack representation. Provide a build_multianewarray. FIXME */
14522   return build (CALL_EXPR, array_type,
14523                 build_address_of (soft_multianewarray_node),
14524                 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
14525                            tree_cons (NULL_TREE,
14526                                       build_int_2 (ndims, 0), dims )),
14527                 NULL_TREE);
14528 }
14529
14530 /* 10.6 Array initializer.  */
14531
14532 /* Build a wfl for array element that don't have one, so we can
14533    pin-point errors.  */
14534
14535 static tree
14536 maybe_build_array_element_wfl (tree node)
14537 {
14538   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14539     return build_expr_wfl (NULL_TREE, ctxp->filename,
14540                            ctxp->elc.line, ctxp->elc.prev_col);
14541   else
14542     return NULL_TREE;
14543 }
14544
14545 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14546    identification of initialized arrays easier to detect during walk
14547    and expansion.  */
14548
14549 static tree
14550 build_new_array_init (int location, tree values)
14551 {
14552   tree constructor = build_constructor (NULL_TREE, values);
14553   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14554   EXPR_WFL_LINECOL (to_return) = location;
14555   return to_return;
14556 }
14557
14558 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14559    occurred.  Otherwise return NODE after having set its type
14560    appropriately.  */
14561
14562 static tree
14563 patch_new_array_init (tree type, tree node)
14564 {
14565   int error_seen = 0;
14566   tree current, element_type;
14567   HOST_WIDE_INT length;
14568   int all_constant = 1;
14569   tree init = TREE_OPERAND (node, 0);
14570
14571   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14572     {
14573       parse_error_context (node,
14574                            "Invalid array initializer for non-array type `%s'",
14575                            lang_printable_name (type, 1));
14576       return error_mark_node;
14577     }
14578   type = TREE_TYPE (type);
14579   element_type = TYPE_ARRAY_ELEMENT (type);
14580
14581   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14582
14583   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14584        current;  length++, current = TREE_CHAIN (current))
14585     {
14586       tree elt = TREE_VALUE (current);
14587       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14588         {
14589           error_seen |= array_constructor_check_entry (element_type, current);
14590           elt = TREE_VALUE (current);
14591           /* When compiling to native code, STRING_CST is converted to
14592              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14593           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14594             all_constant = 0;
14595         }
14596       else
14597         {
14598           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14599           TREE_PURPOSE (current) = NULL_TREE;
14600           all_constant = 0;
14601         }
14602       if (elt && TREE_CODE (elt) == TREE_LIST
14603           && TREE_VALUE (elt) == error_mark_node)
14604         error_seen = 1;
14605     }
14606
14607   if (error_seen)
14608     return error_mark_node;
14609
14610   /* Create a new type. We can't reuse the one we have here by
14611      patching its dimension because it originally is of dimension -1
14612      hence reused by gcc. This would prevent triangular arrays. */
14613   type = build_java_array_type (element_type, length);
14614   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14615   TREE_TYPE (node) = promote_type (type);
14616   TREE_CONSTANT (init) = all_constant;
14617   TREE_INVARIANT (init) = all_constant;
14618   TREE_CONSTANT (node) = all_constant;
14619   TREE_INVARIANT (node) = all_constant;
14620   return node;
14621 }
14622
14623 /* Verify that one entry of the initializer element list can be
14624    assigned to the array base type. Report 1 if an error occurred, 0
14625    otherwise.  */
14626
14627 static int
14628 array_constructor_check_entry (tree type, tree entry)
14629 {
14630   char *array_type_string = NULL;       /* For error reports */
14631   tree value, type_value, new_value, wfl_value, patched;
14632   int error_seen = 0;
14633
14634   new_value = NULL_TREE;
14635   wfl_value = TREE_VALUE (entry);
14636
14637   value = java_complete_tree (TREE_VALUE (entry));
14638   /* patch_string return error_mark_node if arg is error_mark_node */
14639   if ((patched = patch_string (value)))
14640     value = patched;
14641   if (value == error_mark_node)
14642     return 1;
14643
14644   type_value = TREE_TYPE (value);
14645
14646   /* At anytime, try_builtin_assignconv can report a warning on
14647      constant overflow during narrowing. */
14648   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14649   new_value = try_builtin_assignconv (wfl_operator, type, value);
14650   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14651     type_value = promote_type (type);
14652
14653   /* Check and report errors */
14654   if (!new_value)
14655     {
14656       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14657                    "Can't" : "Explicit cast needed to");
14658       if (!array_type_string)
14659         array_type_string = xstrdup (lang_printable_name (type, 1));
14660       parse_error_context
14661         (wfl_operator, "Incompatible type for array. %s convert `%s' to `%s'",
14662          msg, lang_printable_name (type_value, 1), array_type_string);
14663       error_seen = 1;
14664     }
14665
14666   if (new_value)
14667     TREE_VALUE (entry) = new_value;
14668
14669   if (array_type_string)
14670     free (array_type_string);
14671
14672   TREE_PURPOSE (entry) = NULL_TREE;
14673   return error_seen;
14674 }
14675
14676 static tree
14677 build_this (int location)
14678 {
14679   tree node = build_wfl_node (this_identifier_node);
14680   TREE_SET_CODE (node, THIS_EXPR);
14681   EXPR_WFL_LINECOL (node) = location;
14682   return node;
14683 }
14684
14685 /* 14.15 The return statement. It builds a modify expression that
14686    assigns the returned value to the RESULT_DECL that hold the value
14687    to be returned. */
14688
14689 static tree
14690 build_return (int location, tree op)
14691 {
14692   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14693   EXPR_WFL_LINECOL (node) = location;
14694   node = build_debugable_stmt (location, node);
14695   return node;
14696 }
14697
14698 static tree
14699 patch_return (tree node)
14700 {
14701   tree return_exp = TREE_OPERAND (node, 0);
14702   tree meth = current_function_decl;
14703   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14704   int error_found = 0;
14705
14706   TREE_TYPE (node) = error_mark_node;
14707   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14708
14709   /* It's invalid to have a return value within a function that is
14710      declared with the keyword void or that is a constructor */
14711   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14712     error_found = 1;
14713
14714   /* It's invalid to use a return statement in a static block */
14715   if (DECL_CLINIT_P (current_function_decl))
14716     error_found = 1;
14717
14718   /* It's invalid to have a no return value within a function that
14719      isn't declared with the keyword `void' */
14720   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14721     error_found = 2;
14722
14723   if (DECL_INSTINIT_P (current_function_decl))
14724     error_found = 1;
14725
14726   if (error_found)
14727     {
14728       if (DECL_INSTINIT_P (current_function_decl))
14729         parse_error_context (wfl_operator,
14730                              "`return' inside instance initializer");
14731
14732       else if (DECL_CLINIT_P (current_function_decl))
14733         parse_error_context (wfl_operator,
14734                              "`return' inside static initializer");
14735
14736       else if (!DECL_CONSTRUCTOR_P (meth))
14737         {
14738           char *t = xstrdup (lang_printable_name (mtype, 0));
14739           parse_error_context (wfl_operator,
14740                                "`return' with%s value from `%s %s'",
14741                                (error_found == 1 ? "" : "out"),
14742                                t, lang_printable_name (meth, 0));
14743           free (t);
14744         }
14745       else
14746         parse_error_context (wfl_operator,
14747                              "`return' with value from constructor `%s'",
14748                              lang_printable_name (meth, 0));
14749       return error_mark_node;
14750     }
14751
14752   /* If we have a return_exp, build a modify expression and expand
14753      it. Note: at that point, the assignment is declared valid, but we
14754      may want to carry some more hacks */
14755   if (return_exp)
14756     {
14757       tree exp = java_complete_tree (return_exp);
14758       tree modify, patched;
14759
14760       if ((patched = patch_string (exp)))
14761         exp = patched;
14762
14763       modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14764       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14765       modify = java_complete_tree (modify);
14766
14767       if (modify != error_mark_node)
14768         {
14769           TREE_SIDE_EFFECTS (modify) = 1;
14770           TREE_OPERAND (node, 0) = modify;
14771         }
14772       else
14773         return error_mark_node;
14774     }
14775   TREE_TYPE (node) = void_type_node;
14776   TREE_SIDE_EFFECTS (node) = 1;
14777   return node;
14778 }
14779
14780 /* 14.8 The if Statement */
14781
14782 static tree
14783 build_if_else_statement (int location, tree expression, tree if_body,
14784                          tree else_body)
14785 {
14786   tree node;
14787   if (!else_body)
14788     else_body = build_java_empty_stmt ();
14789   node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14790   EXPR_WFL_LINECOL (node) = location;
14791   node = build_debugable_stmt (location, node);
14792   return node;
14793 }
14794
14795 static tree
14796 patch_if_else_statement (tree node)
14797 {
14798   tree expression = TREE_OPERAND (node, 0);
14799   int can_complete_normally
14800     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14801        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14802
14803   TREE_TYPE (node) = error_mark_node;
14804   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14805
14806   /* The type of expression must be boolean */
14807   if (TREE_TYPE (expression) != boolean_type_node
14808       && TREE_TYPE (expression) != promoted_boolean_type_node)
14809     {
14810       parse_error_context
14811         (wfl_operator,
14812          "Incompatible type for `if'. Can't convert `%s' to `boolean'",
14813          lang_printable_name (TREE_TYPE (expression), 0));
14814       return error_mark_node;
14815     }
14816
14817   TREE_TYPE (node) = void_type_node;
14818   TREE_SIDE_EFFECTS (node) = 1;
14819   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14820   return node;
14821 }
14822
14823 /* 14.6 Labeled Statements */
14824
14825 /* Action taken when a labeled statement is parsed. a new
14826    LABELED_BLOCK_EXPR is created. No statement is attached to the
14827    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14828
14829 static tree
14830 build_labeled_block (int location, tree label)
14831 {
14832   tree label_name ;
14833   tree label_decl, node;
14834   if (label == NULL_TREE || label == continue_identifier_node)
14835     label_name = label;
14836   else
14837     {
14838       label_name = merge_qualified_name (label_id, label);
14839       /* Issue an error if we try to reuse a label that was previously
14840          declared */
14841       if (IDENTIFIER_LOCAL_VALUE (label_name))
14842         {
14843           EXPR_WFL_LINECOL (wfl_operator) = location;
14844           parse_error_context (wfl_operator,
14845             "Declaration of `%s' shadows a previous label declaration",
14846                                IDENTIFIER_POINTER (label));
14847           EXPR_WFL_LINECOL (wfl_operator) =
14848             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14849           parse_error_context (wfl_operator,
14850             "This is the location of the previous declaration of label `%s'",
14851                                IDENTIFIER_POINTER (label));
14852           java_error_count--;
14853         }
14854     }
14855
14856   label_decl = create_label_decl (label_name);
14857   node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14858   EXPR_WFL_LINECOL (node) = location;
14859   TREE_SIDE_EFFECTS (node) = 1;
14860   return node;
14861 }
14862
14863 /* A labeled statement LBE is attached a statement.  */
14864
14865 static tree
14866 finish_labeled_statement (tree lbe, /* Labeled block expr */
14867                           tree statement)
14868 {
14869   /* In anyways, tie the loop to its statement */
14870   LABELED_BLOCK_BODY (lbe) = statement;
14871   pop_labeled_block ();
14872   POP_LABELED_BLOCK ();
14873   return lbe;
14874 }
14875
14876 /* 14.10, 14.11, 14.12 Loop Statements */
14877
14878 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14879    list. */
14880
14881 static tree
14882 build_new_loop (tree loop_body)
14883 {
14884   tree loop =  build (LOOP_EXPR, NULL_TREE, loop_body);
14885   TREE_SIDE_EFFECTS (loop) = 1;
14886   PUSH_LOOP (loop);
14887   return loop;
14888 }
14889
14890 /* Create a loop body according to the following structure:
14891      COMPOUND_EXPR
14892        COMPOUND_EXPR            (loop main body)
14893          EXIT_EXPR              (this order is for while/for loops.
14894          LABELED_BLOCK_EXPR      the order is reversed for do loops)
14895            LABEL_DECL           (a continue occurring here branches at the
14896            BODY                  end of this labeled block)
14897        INCREMENT                (if any)
14898
14899   REVERSED, if nonzero, tells that the loop condition expr comes
14900   after the body, like in the do-while loop.
14901
14902   To obtain a loop, the loop body structure described above is
14903   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14904
14905    LABELED_BLOCK_EXPR
14906      LABEL_DECL                   (use this label to exit the loop)
14907      LOOP_EXPR
14908        <structure described above> */
14909
14910 static tree
14911 build_loop_body (int location, tree condition, int reversed)
14912 {
14913   tree first, second, body;
14914
14915   condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14916   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14917   condition = build_debugable_stmt (location, condition);
14918   TREE_SIDE_EFFECTS (condition) = 1;
14919
14920   body = build_labeled_block (0, continue_identifier_node);
14921   first = (reversed ? body : condition);
14922   second = (reversed ? condition : body);
14923   return
14924     build (COMPOUND_EXPR, NULL_TREE,
14925            build (COMPOUND_EXPR, NULL_TREE, first, second),
14926                   build_java_empty_stmt ());
14927 }
14928
14929 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14930    their order) on the current loop. Unlink the current loop from the
14931    loop list.  */
14932
14933 static tree
14934 finish_loop_body (int location, tree condition, tree body, int reversed)
14935 {
14936   tree to_return = ctxp->current_loop;
14937   tree loop_body = LOOP_EXPR_BODY (to_return);
14938   if (condition)
14939     {
14940       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14941       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14942          The real EXIT_EXPR is one operand further. */
14943       EXPR_WFL_LINECOL (cnode) = location;
14944       /* This one is for accurate error reports */
14945       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14946       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14947     }
14948   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14949   POP_LOOP ();
14950   return to_return;
14951 }
14952
14953 /* Tailored version of finish_loop_body for FOR loops, when FOR
14954    loops feature the condition part */
14955
14956 static tree
14957 finish_for_loop (int location, tree condition, tree update, tree body)
14958 {
14959   /* Put the condition and the loop body in place */
14960   tree loop = finish_loop_body (location, condition, body, 0);
14961   /* LOOP is the current loop which has been now popped of the loop
14962      stack.  Mark the update block as reachable and install it.  We do
14963      this because the (current interpretation of the) JLS requires
14964      that the update expression be considered reachable even if the
14965      for loop's body doesn't complete normally.  */
14966   if (update != NULL_TREE && !IS_EMPTY_STMT (update))
14967     {
14968       tree up2 = update;
14969       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
14970         up2 = EXPR_WFL_NODE (up2);
14971       /* It is possible for the update expression to be an
14972          EXPR_WFL_NODE wrapping nothing.  */
14973       if (up2 != NULL_TREE && !IS_EMPTY_STMT (up2))
14974         {
14975           /* Try to detect constraint violations.  These would be
14976              programming errors somewhere.  */
14977           if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
14978               || TREE_CODE (up2) == LOOP_EXPR)
14979             abort ();
14980           SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
14981         }
14982     }
14983   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
14984   return loop;
14985 }
14986
14987 /* Try to find the loop a block might be related to. This comprises
14988    the case where the LOOP_EXPR is found as the second operand of a
14989    COMPOUND_EXPR, because the loop happens to have an initialization
14990    part, then expressed as the first operand of the COMPOUND_EXPR. If
14991    the search finds something, 1 is returned. Otherwise, 0 is
14992    returned. The search is assumed to start from a
14993    LABELED_BLOCK_EXPR's block.  */
14994
14995 static tree
14996 search_loop (tree statement)
14997 {
14998   if (TREE_CODE (statement) == LOOP_EXPR)
14999     return statement;
15000
15001   if (TREE_CODE (statement) == BLOCK)
15002     statement = BLOCK_SUBBLOCKS (statement);
15003   else
15004     return NULL_TREE;
15005
15006   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15007     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15008       statement = TREE_OPERAND (statement, 1);
15009
15010   return (TREE_CODE (statement) == LOOP_EXPR
15011           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
15012 }
15013
15014 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15015    returned otherwise.  */
15016
15017 static int
15018 labeled_block_contains_loop_p (tree block, tree loop)
15019 {
15020   if (!block)
15021     return 0;
15022
15023   if (LABELED_BLOCK_BODY (block) == loop)
15024     return 1;
15025
15026   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
15027     return 1;
15028
15029   return 0;
15030 }
15031
15032 /* If the loop isn't surrounded by a labeled statement, create one and
15033    insert LOOP as its body.  */
15034
15035 static tree
15036 patch_loop_statement (tree loop)
15037 {
15038   tree loop_label;
15039
15040   TREE_TYPE (loop) = void_type_node;
15041   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
15042     return loop;
15043
15044   loop_label = build_labeled_block (0, NULL_TREE);
15045   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15046      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15047   LABELED_BLOCK_BODY (loop_label) = loop;
15048   PUSH_LABELED_BLOCK (loop_label);
15049   return loop_label;
15050 }
15051
15052 /* 14.13, 14.14: break and continue Statements */
15053
15054 /* Build a break or a continue statement. a null NAME indicates an
15055    unlabeled break/continue statement.  */
15056
15057 static tree
15058 build_bc_statement (int location, int is_break, tree name)
15059 {
15060   tree break_continue, label_block_expr = NULL_TREE;
15061
15062   if (name)
15063     {
15064       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15065             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15066         /* Null means that we don't have a target for this named
15067            break/continue. In this case, we make the target to be the
15068            label name, so that the error can be reported accurately in
15069            patch_bc_statement. */
15070         label_block_expr = EXPR_WFL_NODE (name);
15071     }
15072   /* Unlabeled break/continue will be handled during the
15073      break/continue patch operation */
15074   break_continue
15075     = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
15076
15077   IS_BREAK_STMT_P (break_continue) = is_break;
15078   TREE_SIDE_EFFECTS (break_continue) = 1;
15079   EXPR_WFL_LINECOL (break_continue) = location;
15080   break_continue = build_debugable_stmt (location, break_continue);
15081   return break_continue;
15082 }
15083
15084 /* Verification of a break/continue statement. */
15085
15086 static tree
15087 patch_bc_statement (tree node)
15088 {
15089   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15090   tree labeled_block = ctxp->current_labeled_block;
15091   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15092
15093   /* Having an identifier here means that the target is unknown. */
15094   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15095     {
15096       parse_error_context (wfl_operator, "No label definition found for `%s'",
15097                            IDENTIFIER_POINTER (bc_label));
15098       return error_mark_node;
15099     }
15100   if (! IS_BREAK_STMT_P (node))
15101     {
15102       /* It's a continue statement. */
15103       for (;; labeled_block = TREE_CHAIN (labeled_block))
15104         {
15105           if (labeled_block == NULL_TREE)
15106             {
15107               if (bc_label == NULL_TREE)
15108                 parse_error_context (wfl_operator,
15109                                      "`continue' must be in loop");
15110               else
15111                 parse_error_context
15112                   (wfl_operator, "continue label `%s' does not name a loop",
15113                    IDENTIFIER_POINTER (bc_label));
15114               return error_mark_node;
15115             }
15116           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15117                == continue_identifier_node)
15118               && (bc_label == NULL_TREE
15119                   || TREE_CHAIN (labeled_block) == bc_label))
15120             {
15121               bc_label = labeled_block;
15122               break;
15123             }
15124         }
15125     }
15126   else if (!bc_label)
15127     {
15128       for (;; labeled_block = TREE_CHAIN (labeled_block))
15129         {
15130           if (labeled_block == NULL_TREE)
15131             {
15132               parse_error_context (wfl_operator,
15133                                      "`break' must be in loop or switch");
15134               return error_mark_node;
15135             }
15136           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15137           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15138               || search_loop (target_stmt))
15139             {
15140               bc_label = labeled_block;
15141               break;
15142             }
15143         }
15144     }
15145
15146   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15147   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15148
15149   /* Our break/continue don't return values. */
15150   TREE_TYPE (node) = void_type_node;
15151   /* Encapsulate the break within a compound statement so that it's
15152      expanded all the times by expand_expr (and not clobbered
15153      sometimes, like after a if statement) */
15154   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15155   TREE_SIDE_EFFECTS (node) = 1;
15156   return node;
15157 }
15158
15159 /* Process the exit expression belonging to a loop. Its type must be
15160    boolean.  */
15161
15162 static tree
15163 patch_exit_expr (tree node)
15164 {
15165   tree expression = TREE_OPERAND (node, 0);
15166   TREE_TYPE (node) = error_mark_node;
15167   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15168
15169   /* The type of expression must be boolean */
15170   if (TREE_TYPE (expression) != boolean_type_node)
15171     {
15172       parse_error_context
15173         (wfl_operator,
15174     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15175          lang_printable_name (TREE_TYPE (expression), 0));
15176       return error_mark_node;
15177     }
15178   /* Now we know things are allright, invert the condition, fold and
15179      return */
15180   TREE_OPERAND (node, 0) =
15181     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15182
15183   if (! integer_zerop (TREE_OPERAND (node, 0))
15184       && ctxp->current_loop != NULL_TREE
15185       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15186     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15187   if (! integer_onep (TREE_OPERAND (node, 0)))
15188     CAN_COMPLETE_NORMALLY (node) = 1;
15189
15190
15191   TREE_TYPE (node) = void_type_node;
15192   return node;
15193 }
15194
15195 /* 14.9 Switch statement */
15196
15197 static tree
15198 patch_switch_statement (tree node)
15199 {
15200   tree se = TREE_OPERAND (node, 0), se_type;
15201   tree save, iter;
15202
15203   /* Complete the switch expression */
15204   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15205   se_type = TREE_TYPE (se);
15206   /* The type of the switch expression must be char, byte, short or
15207      int */
15208   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15209     {
15210       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15211       parse_error_context (wfl_operator,
15212           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15213                            lang_printable_name (se_type, 0));
15214       /* This is what java_complete_tree will check */
15215       TREE_OPERAND (node, 0) = error_mark_node;
15216       return error_mark_node;
15217     }
15218
15219   /* Save and restore the outer case label list.  */
15220   save = case_label_list;
15221   case_label_list = NULL_TREE;
15222
15223   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15224
15225   /* See if we've found a duplicate label.  We can't leave this until
15226      code generation, because in `--syntax-only' and `-C' modes we
15227      don't do ordinary code generation.  */
15228   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15229     {
15230       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15231       tree subiter;
15232       for (subiter = TREE_CHAIN (iter);
15233            subiter != NULL_TREE;
15234            subiter = TREE_CHAIN (subiter))
15235         {
15236           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15237           if (val == subval)
15238             {
15239               EXPR_WFL_LINECOL (wfl_operator)
15240                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15241               /* The case_label_list is in reverse order, so print the
15242                  outer label first.  */
15243               parse_error_context (wfl_operator, "duplicate case label: `"
15244                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15245               EXPR_WFL_LINECOL (wfl_operator)
15246                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15247               parse_error_context (wfl_operator, "original label is here");
15248
15249               break;
15250             }
15251         }
15252     }
15253
15254   case_label_list = save;
15255
15256   /* Ready to return */
15257   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15258     {
15259       TREE_TYPE (node) = error_mark_node;
15260       return error_mark_node;
15261     }
15262   TREE_TYPE (node) = void_type_node;
15263   TREE_SIDE_EFFECTS (node) = 1;
15264   CAN_COMPLETE_NORMALLY (node)
15265     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15266       || ! SWITCH_HAS_DEFAULT (node);
15267   return node;
15268 }
15269
15270 /* Assertions.  */
15271
15272 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15273    might be NULL_TREE.  */
15274 static tree
15275 build_assertion (int location, tree condition, tree value)
15276 {
15277   tree node;
15278   tree klass = GET_CPC ();
15279
15280   if (! enable_assertions (klass))
15281     {
15282       condition = build (TRUTH_ANDIF_EXPR, NULL_TREE,
15283                          boolean_false_node, condition);
15284       if (value == NULL_TREE)
15285         value = build_java_empty_stmt ();
15286       return build_if_else_statement (location, condition,
15287                                       value, NULL_TREE);
15288     }
15289
15290   if (! CLASS_USES_ASSERTIONS (klass))
15291     {
15292       tree field, classdollar, id, call;
15293       tree class_type = TREE_TYPE (klass);
15294
15295       field = add_field (class_type,
15296                          get_identifier ("$assertionsDisabled"),
15297                          boolean_type_node,
15298                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15299       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15300       FIELD_SYNTHETIC (field) = 1;
15301
15302       classdollar = build_incomplete_class_ref (location, class_type);
15303
15304       /* Call CLASS.desiredAssertionStatus().  */
15305       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15306       call = build (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15307       call = make_qualified_primary (classdollar, call, location);
15308       TREE_SIDE_EFFECTS (call) = 1;
15309
15310       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15311          seem odd, but we do it to generate code identical to that of
15312          the JDK.  */
15313       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15314       TREE_SIDE_EFFECTS (call) = 1;
15315       DECL_INITIAL (field) = call;
15316
15317       /* Record the initializer in the initializer statement list.  */
15318       call = build (MODIFY_EXPR, NULL_TREE, field, call);
15319       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15320       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15321       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15322
15323       CLASS_USES_ASSERTIONS (klass) = 1;
15324     }
15325
15326   if (value != NULL_TREE)
15327     value = tree_cons (NULL_TREE, value, NULL_TREE);
15328
15329   node = build_wfl_node (get_identifier ("java"));
15330   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15331                               location);
15332   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15333                               location);
15334
15335   node = build (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15336   TREE_SIDE_EFFECTS (node) = 1;
15337   /* It is too early to use BUILD_THROW.  */
15338   node = build1 (THROW_EXPR, NULL_TREE, node);
15339   TREE_SIDE_EFFECTS (node) = 1;
15340
15341   /* We invert the condition; if we just put NODE as the `else' part
15342      then we generate weird-looking bytecode.  */
15343   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15344   /* Check $assertionsDisabled.  */
15345   condition
15346     = build (TRUTH_ANDIF_EXPR, NULL_TREE,
15347              build1 (TRUTH_NOT_EXPR, NULL_TREE,
15348                      build_wfl_node (get_identifier ("$assertionsDisabled"))),
15349              condition);
15350   node = build_if_else_statement (location, condition, node, NULL_TREE);
15351   return node;
15352 }
15353
15354 /* 14.18 The try/catch statements */
15355
15356 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15357    catches TYPE and executes CATCH_STMTS.  */
15358
15359 static tree
15360 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15361                             tree catch_stmts)
15362 {
15363   tree try_block, catch_clause_param, catch_block, catch;
15364
15365   /* First build a try block */
15366   try_block = build_expr_block (try_stmts, NULL_TREE);
15367
15368   /* Build a catch block: we need a catch clause parameter */
15369   if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15370     {
15371       tree catch_type = obtain_incomplete_type (type_or_name);
15372       jdep *dep;
15373       catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15374       register_incomplete_type (JDEP_VARIABLE, type_or_name,
15375                                 catch_clause_param, catch_type);
15376       dep = CLASSD_LAST (ctxp->classd_list);
15377       JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15378     }
15379   else
15380     catch_clause_param = build_decl (VAR_DECL, wpv_id,
15381                                      build_pointer_type (type_or_name));
15382
15383   /* And a block */
15384   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15385
15386   /* Initialize the variable and store in the block */
15387   catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15388                  build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15389   add_stmt_to_block (catch_block, NULL_TREE, catch);
15390
15391   /* Add the catch statements */
15392   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15393
15394   /* Now we can build a JAVA_CATCH_EXPR */
15395   catch_block = build1 (JAVA_CATCH_EXPR, NULL_TREE, catch_block);
15396
15397   return build_try_statement (location, try_block, catch_block);
15398 }
15399
15400 static tree
15401 build_try_statement (int location, tree try_block, tree catches)
15402 {
15403   tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
15404   EXPR_WFL_LINECOL (node) = location;
15405   return node;
15406 }
15407
15408 static tree
15409 build_try_finally_statement (int location, tree try_block, tree finally)
15410 {
15411   tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15412   EXPR_WFL_LINECOL (node) = location;
15413   return node;
15414 }
15415
15416 static tree
15417 patch_try_statement (tree node)
15418 {
15419   int error_found = 0;
15420   tree try = TREE_OPERAND (node, 0);
15421   /* Exception handlers are considered in left to right order */
15422   tree catch = nreverse (TREE_OPERAND (node, 1));
15423   tree current, caught_type_list = NULL_TREE;
15424
15425   /* Check catch clauses, if any. Every time we find an error, we try
15426      to process the next catch clause. We process the catch clause before
15427      the try block so that when processing the try block we can check thrown
15428      exceptions againts the caught type list. */
15429   for (current = catch; current; current = TREE_CHAIN (current))
15430     {
15431       tree carg_decl, carg_type;
15432       tree sub_current, catch_block, catch_clause;
15433       int unreachable;
15434
15435       /* At this point, the structure of the catch clause is
15436            JAVA_CATCH_EXPR              (catch node)
15437              BLOCK              (with the decl of the parameter)
15438                COMPOUND_EXPR
15439                  MODIFY_EXPR   (assignment of the catch parameter)
15440                  BLOCK          (catch clause block)
15441        */
15442       catch_clause = TREE_OPERAND (current, 0);
15443       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15444       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15445
15446       /* Catch clauses can't have more than one parameter declared,
15447          but it's already enforced by the grammar. Make sure that the
15448          only parameter of the clause statement in of class Throwable
15449          or a subclass of Throwable, but that was done earlier. The
15450          catch clause parameter type has also been resolved. */
15451
15452       /* Just make sure that the catch clause parameter type inherits
15453          from java.lang.Throwable */
15454       if (!inherits_from_p (carg_type, throwable_type_node))
15455         {
15456           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15457           parse_error_context (wfl_operator,
15458                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15459                                lang_printable_name (carg_type, 0));
15460           error_found = 1;
15461           continue;
15462         }
15463
15464       /* Partial check for unreachable catch statement: The catch
15465          clause is reachable iff is no earlier catch block A in
15466          the try statement such that the type of the catch
15467          clause's parameter is the same as or a subclass of the
15468          type of A's parameter */
15469       unreachable = 0;
15470       for (sub_current = catch;
15471            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15472         {
15473           tree sub_catch_clause, decl;
15474           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15475           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15476
15477           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15478             {
15479               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15480               parse_error_context
15481                 (wfl_operator,
15482                  "`catch' not reached because of the catch clause at line %d",
15483                  EXPR_WFL_LINENO (sub_current));
15484               unreachable = error_found = 1;
15485               break;
15486             }
15487         }
15488       /* Complete the catch clause block */
15489       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15490       if (catch_block == error_mark_node)
15491         {
15492           error_found = 1;
15493           continue;
15494         }
15495       if (CAN_COMPLETE_NORMALLY (catch_block))
15496         CAN_COMPLETE_NORMALLY (node) = 1;
15497       TREE_OPERAND (current, 0) = catch_block;
15498
15499       if (unreachable)
15500         continue;
15501
15502       /* Things to do here: the exception must be thrown */
15503
15504       /* Link this type to the caught type list */
15505       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15506     }
15507
15508   PUSH_EXCEPTIONS (caught_type_list);
15509   if ((try = java_complete_tree (try)) == error_mark_node)
15510     error_found = 1;
15511   if (CAN_COMPLETE_NORMALLY (try))
15512     CAN_COMPLETE_NORMALLY (node) = 1;
15513   POP_EXCEPTIONS ();
15514
15515   /* Verification ends here */
15516   if (error_found)
15517     return error_mark_node;
15518
15519   TREE_OPERAND (node, 0) = try;
15520   TREE_OPERAND (node, 1) = catch;
15521   TREE_TYPE (node) = void_type_node;
15522   return node;
15523 }
15524
15525 /* 14.17 The synchronized Statement */
15526
15527 static tree
15528 patch_synchronized_statement (tree node, tree wfl_op1)
15529 {
15530   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15531   tree block = TREE_OPERAND (node, 1);
15532
15533   tree tmp, enter, exit, expr_decl, assignment;
15534
15535   if (expr == error_mark_node)
15536     {
15537       block = java_complete_tree (block);
15538       return expr;
15539     }
15540
15541   /* We might be trying to synchronize on a STRING_CST */
15542   if ((tmp = patch_string (expr)))
15543     expr = tmp;
15544
15545   /* The TYPE of expr must be a reference type */
15546   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15547     {
15548       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15549       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15550                            lang_printable_name (TREE_TYPE (expr), 0));
15551       return error_mark_node;
15552     }
15553
15554   if (flag_emit_xref)
15555     {
15556       TREE_OPERAND (node, 0) = expr;
15557       TREE_OPERAND (node, 1) = java_complete_tree (block);
15558       CAN_COMPLETE_NORMALLY (node) = 1;
15559       return node;
15560     }
15561
15562   /* Generate a try-finally for the synchronized statement, except
15563      that the handler that catches all throw exception calls
15564      _Jv_MonitorExit and then rethrow the exception.
15565      The synchronized statement is then implemented as:
15566      TRY
15567        {
15568          _Jv_MonitorEnter (expression)
15569          synchronized_block
15570          _Jv_MonitorExit (expression)
15571        }
15572      CATCH_ALL
15573        {
15574          e = _Jv_exception_info ();
15575          _Jv_MonitorExit (expression)
15576          Throw (e);
15577        } */
15578
15579   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15580   BUILD_MONITOR_ENTER (enter, expr_decl);
15581   BUILD_MONITOR_EXIT (exit, expr_decl);
15582   CAN_COMPLETE_NORMALLY (enter) = 1;
15583   CAN_COMPLETE_NORMALLY (exit) = 1;
15584   assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15585   TREE_SIDE_EFFECTS (assignment) = 1;
15586   node = build (COMPOUND_EXPR, NULL_TREE,
15587                 build (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15588                 build (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15589   node = build_expr_block (node, expr_decl);
15590
15591   return java_complete_tree (node);
15592 }
15593
15594 /* 14.16 The throw Statement */
15595
15596 static tree
15597 patch_throw_statement (tree node, tree wfl_op1)
15598 {
15599   tree expr = TREE_OPERAND (node, 0);
15600   tree type = TREE_TYPE (expr);
15601   int unchecked_ok = 0, tryblock_throws_ok = 0;
15602
15603   /* Thrown expression must be assignable to java.lang.Throwable */
15604   if (!try_reference_assignconv (throwable_type_node, expr))
15605     {
15606       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15607       parse_error_context (wfl_operator,
15608     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15609                            lang_printable_name (type, 0));
15610       /* If the thrown expression was a reference, we further the
15611          compile-time check. */
15612       if (!JREFERENCE_TYPE_P (type))
15613         return error_mark_node;
15614     }
15615
15616   /* At least one of the following must be true */
15617
15618   /* The type of the throw expression is a not checked exception,
15619      i.e. is a unchecked expression. */
15620   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15621
15622   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15623   /* An instance can't throw a checked exception unless that exception
15624      is explicitly declared in the `throws' clause of each
15625      constructor. This doesn't apply to anonymous classes, since they
15626      don't have declared constructors. */
15627   if (!unchecked_ok
15628       && DECL_INSTINIT_P (current_function_decl)
15629       && !ANONYMOUS_CLASS_P (current_class))
15630     {
15631       tree current;
15632       for (current = TYPE_METHODS (current_class); current;
15633            current = TREE_CHAIN (current))
15634         if (DECL_CONSTRUCTOR_P (current)
15635             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15636           {
15637             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)",
15638                                  lang_printable_name (TREE_TYPE (expr), 0));
15639             return error_mark_node;
15640           }
15641     }
15642
15643   /* Throw is contained in a try statement and at least one catch
15644      clause can receive the thrown expression or the current method is
15645      declared to throw such an exception. Or, the throw statement is
15646      contained in a method or constructor declaration and the type of
15647      the Expression is assignable to at least one type listed in the
15648      throws clause the declaration. */
15649   if (!unchecked_ok)
15650     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15651   if (!(unchecked_ok || tryblock_throws_ok))
15652     {
15653       /* If there is a surrounding try block that has no matching
15654          clatch clause, report it first. A surrounding try block exits
15655          only if there is something after the list of checked
15656          exception thrown by the current function (if any). */
15657       if (IN_TRY_BLOCK_P ())
15658         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15659                              lang_printable_name (type, 0));
15660       /* If we have no surrounding try statement and the method doesn't have
15661          any throws, report it now. FIXME */
15662
15663       /* We report that the exception can't be throw from a try block
15664          in all circumstances but when the `throw' is inside a static
15665          block. */
15666       else if (!EXCEPTIONS_P (currently_caught_type_list)
15667                && !tryblock_throws_ok)
15668         {
15669           if (DECL_CLINIT_P (current_function_decl))
15670             parse_error_context (wfl_operator,
15671                    "Checked exception `%s' can't be thrown in initializer",
15672                                  lang_printable_name (type, 0));
15673           else
15674             parse_error_context (wfl_operator,
15675                    "Checked exception `%s' isn't thrown from a `try' block",
15676                                  lang_printable_name (type, 0));
15677         }
15678       /* Otherwise, the current method doesn't have the appropriate
15679          throws declaration */
15680       else
15681         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15682                              lang_printable_name (type, 0));
15683       return error_mark_node;
15684     }
15685
15686   if (! flag_emit_class_files && ! flag_emit_xref)
15687     BUILD_THROW (node, expr);
15688
15689   /* If doing xrefs, keep the location where the `throw' was seen. */
15690   if (flag_emit_xref)
15691     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15692   return node;
15693 }
15694
15695 /* Check that exception said to be thrown by method DECL can be
15696    effectively caught from where DECL is invoked.  THIS_EXPR is the
15697    expression that computes `this' for the method call.  */
15698 static void
15699 check_thrown_exceptions (int location, tree decl, tree this_expr)
15700 {
15701   tree throws;
15702   int is_array_call = 0;
15703
15704   /* Skip check within generated methods, such as access$<n>.  */
15705   if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
15706     return;
15707
15708   if (this_expr != NULL_TREE
15709       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15710       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15711     is_array_call = 1;
15712
15713   /* For all the unchecked exceptions thrown by DECL.  */
15714   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15715        throws = TREE_CHAIN (throws))
15716     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15717       {
15718         /* Suppress errors about cloning arrays.  */
15719         if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15720           continue;
15721
15722         EXPR_WFL_LINECOL (wfl_operator) = location;
15723         if (DECL_FINIT_P (current_function_decl))
15724           parse_error_context
15725             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15726              lang_printable_name (TREE_VALUE (throws), 0));
15727         else
15728           {
15729             parse_error_context
15730               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15731                lang_printable_name (TREE_VALUE (throws), 0),
15732                (DECL_INIT_P (current_function_decl) ?
15733                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15734                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15735           }
15736       }
15737 }
15738
15739 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15740    try-catch blocks, OR is listed in the `throws' clause of the
15741    current method.  */
15742
15743 static int
15744 check_thrown_exceptions_do (tree exception)
15745 {
15746   tree list = currently_caught_type_list;
15747   resolve_and_layout (exception, NULL_TREE);
15748   /* First, all the nested try-catch-finally at that stage. The
15749      last element contains `throws' clause exceptions, if any. */
15750   if (IS_UNCHECKED_EXCEPTION_P (exception))
15751     return 1;
15752   while (list)
15753     {
15754       tree caught;
15755       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15756         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15757           return 1;
15758       list = TREE_CHAIN (list);
15759     }
15760   return 0;
15761 }
15762
15763 static void
15764 purge_unchecked_exceptions (tree mdecl)
15765 {
15766   tree throws = DECL_FUNCTION_THROWS (mdecl);
15767   tree new = NULL_TREE;
15768
15769   while (throws)
15770     {
15771       tree next = TREE_CHAIN (throws);
15772       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15773         {
15774           TREE_CHAIN (throws) = new;
15775           new = throws;
15776         }
15777       throws = next;
15778     }
15779   /* List is inverted here, but it doesn't matter */
15780   DECL_FUNCTION_THROWS (mdecl) = new;
15781 }
15782
15783 /* This function goes over all of CLASS_TYPE ctors and checks whether
15784    each of them features at least one unchecked exception in its
15785    `throws' clause. If it's the case, it returns `true', `false'
15786    otherwise.  */
15787
15788 static bool
15789 ctors_unchecked_throws_clause_p (tree class_type)
15790 {
15791   tree current;
15792
15793   for (current = TYPE_METHODS (class_type); current;
15794        current = TREE_CHAIN (current))
15795     {
15796       bool ctu = false; /* Ctor Throws Unchecked */
15797       if (DECL_CONSTRUCTOR_P (current))
15798         {
15799           tree throws;
15800           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15801                throws = TREE_CHAIN (throws))
15802             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15803               ctu = true;
15804         }
15805       /* We return false as we found one ctor that is unfit. */
15806       if (!ctu && DECL_CONSTRUCTOR_P (current))
15807         return false;
15808     }
15809   /* All ctors feature at least one unchecked exception in their
15810      `throws' clause. */
15811   return true;
15812 }
15813
15814 /* 15.24 Conditional Operator ?: */
15815
15816 static tree
15817 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15818 {
15819   tree cond = TREE_OPERAND (node, 0);
15820   tree op1 = TREE_OPERAND (node, 1);
15821   tree op2 = TREE_OPERAND (node, 2);
15822   tree resulting_type = NULL_TREE;
15823   tree t1, t2, patched;
15824   int error_found = 0;
15825
15826   /* Operands of ?: might be StringBuffers crafted as a result of a
15827      string concatenation. Obtain a descent operand here.  */
15828   if ((patched = patch_string (op1)))
15829     TREE_OPERAND (node, 1) = op1 = patched;
15830   if ((patched = patch_string (op2)))
15831     TREE_OPERAND (node, 2) = op2 = patched;
15832
15833   t1 = TREE_TYPE (op1);
15834   t2 = TREE_TYPE (op2);
15835
15836   /* The first expression must be a boolean */
15837   if (TREE_TYPE (cond) != boolean_type_node)
15838     {
15839       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15840       parse_error_context (wfl_operator,
15841                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15842                            lang_printable_name (TREE_TYPE (cond), 0));
15843       error_found = 1;
15844     }
15845
15846   /* Second and third can be numeric, boolean (i.e. primitive),
15847      references or null. Anything else results in an error */
15848   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15849         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15850             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15851         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15852     error_found = 1;
15853
15854   /* Determine the type of the conditional expression. Same types are
15855      easy to deal with */
15856   else if (t1 == t2)
15857     resulting_type = t1;
15858
15859   /* There are different rules for numeric types */
15860   else if (JNUMERIC_TYPE_P (t1))
15861     {
15862       /* if byte/short found, the resulting type is short */
15863       if ((t1 == byte_type_node && t2 == short_type_node)
15864           || (t1 == short_type_node && t2 == byte_type_node))
15865         resulting_type = short_type_node;
15866
15867       /* If t1 is a constant int and t2 is of type byte, short or char
15868          and t1's value fits in t2, then the resulting type is t2 */
15869       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15870           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15871         resulting_type = t2;
15872
15873       /* If t2 is a constant int and t1 is of type byte, short or char
15874          and t2's value fits in t1, then the resulting type is t1 */
15875       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15876           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15877         resulting_type = t1;
15878
15879       /* Otherwise, binary numeric promotion is applied and the
15880          resulting type is the promoted type of operand 1 and 2 */
15881       else
15882         resulting_type = binary_numeric_promotion (t1, t2,
15883                                                    &TREE_OPERAND (node, 1),
15884                                                    &TREE_OPERAND (node, 2));
15885     }
15886
15887   /* Cases of a reference and a null type */
15888   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15889     resulting_type = t1;
15890
15891   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15892     resulting_type = t2;
15893
15894   /* Last case: different reference types. If a type can be converted
15895      into the other one by assignment conversion, the latter
15896      determines the type of the expression */
15897   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15898     resulting_type = promote_type (t1);
15899
15900   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15901     resulting_type = promote_type (t2);
15902
15903   /* If we don't have any resulting type, we're in trouble */
15904   if (!resulting_type)
15905     {
15906       char *t = xstrdup (lang_printable_name (t1, 0));
15907       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15908       parse_error_context (wfl_operator,
15909                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15910                            t, lang_printable_name (t2, 0));
15911       free (t);
15912       error_found = 1;
15913     }
15914
15915   if (error_found)
15916     {
15917       TREE_TYPE (node) = error_mark_node;
15918       return error_mark_node;
15919     }
15920
15921   TREE_TYPE (node) = resulting_type;
15922   TREE_SET_CODE (node, COND_EXPR);
15923   CAN_COMPLETE_NORMALLY (node) = 1;
15924   return node;
15925 }
15926
15927 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15928
15929 static tree
15930 maybe_build_class_init_for_field (tree decl, tree expr)
15931 {
15932   tree clas = DECL_CONTEXT (decl);
15933   if (flag_emit_class_files || flag_emit_xref)
15934     return expr;
15935
15936   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
15937       && FIELD_FINAL (decl))
15938     {
15939       tree init = DECL_INITIAL (decl);
15940       if (init != NULL_TREE)
15941         init = fold_constant_for_init (init, decl);
15942       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
15943         return expr;
15944     }
15945
15946   return build_class_init (clas, expr);
15947 }
15948
15949 /* Try to constant fold NODE.
15950    If NODE is not a constant expression, return NULL_EXPR.
15951    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15952
15953 static tree
15954 fold_constant_for_init (tree node, tree context)
15955 {
15956   tree op0, op1, val;
15957   enum tree_code code = TREE_CODE (node);
15958
15959   switch (code)
15960     {
15961     case INTEGER_CST:
15962       if (node == null_pointer_node)
15963         return NULL_TREE;
15964     case STRING_CST:
15965     case REAL_CST:
15966       return node;
15967
15968     case PLUS_EXPR:
15969     case MINUS_EXPR:
15970     case MULT_EXPR:
15971     case TRUNC_MOD_EXPR:
15972     case RDIV_EXPR:
15973     case LSHIFT_EXPR:
15974     case RSHIFT_EXPR:
15975     case URSHIFT_EXPR:
15976     case BIT_AND_EXPR:
15977     case BIT_XOR_EXPR:
15978     case BIT_IOR_EXPR:
15979     case TRUTH_ANDIF_EXPR:
15980     case TRUTH_ORIF_EXPR:
15981     case EQ_EXPR:
15982     case NE_EXPR:
15983     case GT_EXPR:
15984     case GE_EXPR:
15985     case LT_EXPR:
15986     case LE_EXPR:
15987       op0 = TREE_OPERAND (node, 0);
15988       op1 = TREE_OPERAND (node, 1);
15989       val = fold_constant_for_init (op0, context);
15990       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15991         return NULL_TREE;
15992       TREE_OPERAND (node, 0) = val;
15993       val = fold_constant_for_init (op1, context);
15994       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15995         return NULL_TREE;
15996       TREE_OPERAND (node, 1) = val;
15997       return patch_binop (node, op0, op1);
15998
15999     case UNARY_PLUS_EXPR:
16000     case NEGATE_EXPR:
16001     case TRUTH_NOT_EXPR:
16002     case BIT_NOT_EXPR:
16003     case CONVERT_EXPR:
16004       op0 = TREE_OPERAND (node, 0);
16005       val = fold_constant_for_init (op0, context);
16006       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16007         return NULL_TREE;
16008       TREE_OPERAND (node, 0) = val;
16009       val = patch_unaryop (node, op0);
16010       if (! TREE_CONSTANT (val))
16011         return NULL_TREE;
16012       return val;
16013
16014       break;
16015
16016     case COND_EXPR:
16017       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
16018       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16019         return NULL_TREE;
16020       TREE_OPERAND (node, 0) = val;
16021       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
16022       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16023         return NULL_TREE;
16024       TREE_OPERAND (node, 1) = val;
16025       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
16026       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16027         return NULL_TREE;
16028       TREE_OPERAND (node, 2) = val;
16029       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
16030         : TREE_OPERAND (node, 2);
16031
16032     case VAR_DECL:
16033     case FIELD_DECL:
16034       if (! FIELD_FINAL (node)
16035           || DECL_INITIAL (node) == NULL_TREE)
16036         return NULL_TREE;
16037       val = DECL_INITIAL (node);
16038       /* Guard against infinite recursion. */
16039       DECL_INITIAL (node) = NULL_TREE;
16040       val = fold_constant_for_init (val, node);
16041       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
16042         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
16043       DECL_INITIAL (node) = val;
16044       return val;
16045
16046     case EXPR_WITH_FILE_LOCATION:
16047       /* Compare java_complete_tree and resolve_expression_name. */
16048       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
16049           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
16050         {
16051           tree name = EXPR_WFL_NODE (node);
16052           tree decl;
16053           if (PRIMARY_P (node))
16054             return NULL_TREE;
16055           else if (! QUALIFIED_P (name))
16056             {
16057               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
16058               if (decl == NULL_TREE
16059                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16060                 return NULL_TREE;
16061               return fold_constant_for_init (decl, decl);
16062             }
16063           else
16064             {
16065               /* Install the proper context for the field resolution.
16066                  The prior context is restored once the name is
16067                  properly qualified. */
16068               tree saved_current_class = current_class;
16069               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
16070               current_class = DECL_CONTEXT (context);
16071               qualify_ambiguous_name (node);
16072               current_class = saved_current_class;
16073               if (resolve_field_access (node, &decl, NULL)
16074                   && decl != NULL_TREE)
16075                 return fold_constant_for_init (decl, decl);
16076               return NULL_TREE;
16077             }
16078         }
16079       else
16080         {
16081           op0 = TREE_OPERAND (node, 0);
16082           val = fold_constant_for_init (op0, context);
16083           if (val == NULL_TREE || ! TREE_CONSTANT (val))
16084             return NULL_TREE;
16085           TREE_OPERAND (node, 0) = val;
16086           return val;
16087         }
16088
16089 #ifdef USE_COMPONENT_REF
16090     case IDENTIFIER:
16091     case COMPONENT_REF:
16092       ?;
16093 #endif
16094
16095     default:
16096       return NULL_TREE;
16097     }
16098 }
16099
16100 #ifdef USE_COMPONENT_REF
16101 /* Context is 'T' for TypeName, 'P' for PackageName,
16102    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16103
16104 tree
16105 resolve_simple_name (tree name, int context)
16106 {
16107 }
16108
16109 tree
16110 resolve_qualified_name (tree name, int context)
16111 {
16112 }
16113 #endif
16114
16115 void
16116 init_src_parse (void)
16117 {
16118   /* Sanity check; we've been bit by this before.  */
16119   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16120     abort ();
16121 }
16122
16123 \f
16124
16125 /* This section deals with the functions that are called when tables
16126    recording class initialization information are traversed.  */
16127
16128 /* Attach to PTR (a block) the declaration found in ENTRY. */
16129
16130 static int
16131 attach_init_test_initialization_flags (void **entry, void *ptr)
16132 {
16133   tree block = (tree)ptr;
16134   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16135
16136   if (block != error_mark_node)
16137     {
16138       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16139       BLOCK_EXPR_DECLS (block) = ite->value;
16140     }
16141   return true;
16142 }
16143
16144 /* This function is called for each class that is known definitely
16145    initialized when a given static method was called. This function
16146    augments a compound expression (INFO) storing all assignment to
16147    initialized static class flags if a flag already existed, otherwise
16148    a new one is created.  */
16149
16150 static int
16151 emit_test_initialization (void **entry_p, void *info)
16152 {
16153   tree l = (tree) info;
16154   tree decl, init;
16155   tree key = (tree) *entry_p;
16156   tree *ite;
16157   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16158
16159   /* If we haven't found a flag and we're dealing with self registered
16160      with current_function_decl, then don't do anything. Self is
16161      always added as definitely initialized but this information is
16162      valid only if used outside the current function. */
16163   if (current_function_decl == TREE_PURPOSE (l)
16164       && java_treetreehash_find (cf_ht, key) == NULL)
16165     return true;
16166
16167   ite = java_treetreehash_new (cf_ht, key);
16168
16169   /* If we don't have a variable, create one and install it. */
16170   if (*ite == NULL)
16171     {
16172       tree block;
16173
16174       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16175       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16176       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16177       DECL_CONTEXT (decl) = current_function_decl;
16178       DECL_INITIAL (decl) = boolean_true_node;
16179       /* Don't emit any symbolic debugging info for this decl.  */
16180       DECL_IGNORED_P (decl) = 1;
16181
16182       /* The trick is to find the right context for it. */
16183       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16184       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16185       BLOCK_EXPR_DECLS (block) = decl;
16186       *ite = decl;
16187     }
16188   else
16189     decl = *ite;
16190
16191   /* Now simply augment the compound that holds all the assignments
16192      pertaining to this method invocation. */
16193   init = build (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16194   TREE_SIDE_EFFECTS (init) = 1;
16195   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16196   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16197
16198   return true;
16199 }
16200
16201 #include "gt-java-parse.h"
16202 #include "gtype-java.h"