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
  76 /* Local function prototypes */
  77 static char *java_accstring_lookup (int);
  78 static void  classitf_redefinition_error (const char *,tree, tree, tree);
  79 static void  variable_redefinition_error (tree, tree, tree, int);
  80 static tree  create_class (int, tree, tree, tree);
  81 static tree  create_interface (int, tree, tree);
  82 static void  end_class_declaration (int);
  83 static tree  find_field (tree, tree);
  84 static tree lookup_field_wrapper (tree, tree);
  85 static int   duplicate_declaration_error_p (tree, tree, tree);
  86 static void  register_fields (int, tree, tree);
  87 static tree parser_qualified_classname (tree);
  88 static int  parser_check_super (tree, tree, tree);
  89 static int  parser_check_super_interface (tree, tree, tree);
  90 static void check_modifiers_consistency (int);
  91 static tree lookup_cl (tree);
  92 static tree lookup_java_method2 (tree, tree, int);
  93 static tree method_header (int, tree, tree, tree);
  94 static void fix_method_argument_names (tree ,tree);
  95 static tree method_declarator (tree, tree);
  96 static void parse_warning_context (tree cl, const char *msg, ...)
  97   ATTRIBUTE_PRINTF_2;
  98 static void issue_warning_error_from_context (tree, const char *msg, va_list)
  99   ATTRIBUTE_PRINTF (2, 0);
 100 static void parse_ctor_invocation_error (void);
 101 static tree parse_jdk1_1_error (const char *);
 102 static void complete_class_report_errors (jdep *);
 103 static int process_imports (void);
 104 static void read_import_dir (tree);
 105 static int find_in_imports_on_demand (tree, tree);
 106 static void find_in_imports (tree, tree);
 107 static void check_inner_class_access (tree, tree, tree);
 108 static int check_pkg_class_access (tree, tree, bool);
 109 static void register_package (tree);
 110 static tree resolve_package (tree, tree *, tree *);
 111 static tree resolve_class (tree, tree, tree, tree);
 112 static void declare_local_variables (int, tree, tree);
 113 static void dump_java_tree (enum tree_dump_index, tree);
 114 static void source_start_java_method (tree);
 115 static void source_end_java_method (void);
 116 static tree find_name_in_single_imports (tree);
 117 static void check_abstract_method_header (tree);
 118 static tree lookup_java_interface_method2 (tree, tree);
 119 static tree resolve_expression_name (tree, tree *);
 120 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
 121 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
 122 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
 123 static int breakdown_qualified (tree *, tree *, tree);
 124 static int in_same_package (tree, tree);
 125 static tree resolve_and_layout (tree, tree);
 126 static tree qualify_and_find (tree, tree, tree);
 127 static tree resolve_no_layout (tree, tree);
 128 static int invocation_mode (tree, int);
 129 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
 130 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
 131 static tree find_most_specific_methods_list (tree);
 132 static int argument_types_convertible (tree, tree);
 133 static tree patch_invoke (tree, tree, tree);
 134 static int maybe_use_access_method (int, tree *, tree *);
 135 static tree lookup_method_invoke (int, tree, tree, tree, tree);
 136 static tree register_incomplete_type (int, tree, tree, tree);
 137 static tree check_inner_circular_reference (tree, tree);
 138 static tree check_circular_reference (tree);
 139 static tree obtain_incomplete_type (tree);
 140 static tree java_complete_lhs (tree);
 141 static tree java_complete_tree (tree);
 142 static tree maybe_generate_pre_expand_clinit (tree);
 143 static int analyze_clinit_body (tree, tree);
 144 static int maybe_yank_clinit (tree);
 145 static void java_complete_expand_method (tree);
 146 static void java_expand_method_bodies (tree);
 147 static int  unresolved_type_p (tree, tree *);
 148 static void create_jdep_list (struct parser_ctxt *);
 149 static tree build_expr_block (tree, tree);
 150 static tree enter_block (void);
 151 static tree exit_block (void);
 152 static tree lookup_name_in_blocks (tree);
 153 static void maybe_absorb_scoping_blocks (void);
 154 static tree build_method_invocation (tree, tree);
 155 static tree build_new_invocation (tree, tree);
 156 static tree build_assignment (int, int, tree, tree);
 157 static tree build_binop (enum tree_code, int, tree, tree);
 158 static tree patch_assignment (tree, tree);
 159 static tree patch_binop (tree, tree, tree);
 160 static tree build_unaryop (int, int, tree);
 161 static tree build_incdec (int, int, tree, int);
 162 static tree patch_unaryop (tree, tree);
 163 static tree build_cast (int, tree, tree);
 164 static tree build_null_of_type (tree);
 165 static tree patch_cast (tree, tree);
 166 static int valid_ref_assignconv_cast_p (tree, tree, int);
 167 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
 168 static int valid_cast_to_p (tree, tree);
 169 static int valid_method_invocation_conversion_p (tree, tree);
 170 static tree try_builtin_assignconv (tree, tree, tree);
 171 static tree try_reference_assignconv (tree, tree);
 172 static tree build_unresolved_array_type (tree);
 173 static int build_type_name_from_array_name (tree, tree *);
 174 static tree build_array_from_name (tree, tree, tree, tree *);
 175 static tree build_array_ref (int, tree, tree);
 176 static tree patch_array_ref (tree);
 177 static tree make_qualified_name (tree, tree, int);
 178 static tree merge_qualified_name (tree, tree);
 179 static tree make_qualified_primary (tree, tree, int);
 180 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
 181 static void qualify_ambiguous_name (tree);
 182 static tree resolve_field_access (tree, tree *, tree *);
 183 static tree build_newarray_node (tree, tree, int);
 184 static tree patch_newarray (tree);
 185 static tree resolve_type_during_patch (tree);
 186 static tree build_this (int);
 187 static tree build_wfl_wrap (tree, int);
 188 static tree build_return (int, tree);
 189 static tree patch_return (tree);
 190 static tree maybe_access_field (tree, tree, tree);
 191 static int complete_function_arguments (tree);
 192 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
 193 static int not_accessible_p (tree, tree, tree, int);
 194 static void check_deprecation (tree, tree);
 195 static int class_in_current_package (tree);
 196 static tree build_if_else_statement (int, tree, tree, tree);
 197 static tree patch_if_else_statement (tree);
 198 static tree add_stmt_to_compound (tree, tree, tree);
 199 static tree add_stmt_to_block (tree, tree, tree);
 200 static tree patch_exit_expr (tree);
 201 static tree build_labeled_block (int, tree);
 202 static tree finish_labeled_statement (tree, tree);
 203 static tree build_bc_statement (int, int, tree);
 204 static tree patch_bc_statement (tree);
 205 static tree patch_loop_statement (tree);
 206 static tree build_new_loop (tree);
 207 static tree build_loop_body (int, tree, int);
 208 static tree finish_loop_body (int, tree, tree, int);
 209 static tree build_debugable_stmt (int, tree);
 210 static tree finish_for_loop (int, tree, tree, tree);
 211 static tree patch_switch_statement (tree);
 212 static tree string_constant_concatenation (tree, tree);
 213 static tree build_string_concatenation (tree, tree);
 214 static tree patch_string_cst (tree);
 215 static tree patch_string (tree);
 216 static tree encapsulate_with_try_catch (int, tree, tree, tree);
 217 static tree build_assertion (int, tree, tree);
 218 static tree build_try_statement (int, tree, tree);
 219 static tree build_try_finally_statement (int, tree, tree);
 220 static tree patch_try_statement (tree);
 221 static tree patch_synchronized_statement (tree, tree);
 222 static tree patch_throw_statement (tree, tree);
 223 static void check_thrown_exceptions (int, tree, tree);
 224 static int check_thrown_exceptions_do (tree);
 225 static void purge_unchecked_exceptions (tree);
 226 static bool ctors_unchecked_throws_clause_p (tree);
 227 static void check_concrete_throws_clauses (tree, tree, tree, tree);
 228 static void check_throws_clauses (tree, tree, tree);
 229 static void finish_method_declaration (tree);
 230 static tree build_super_invocation (tree);
 231 static int verify_constructor_circularity (tree, tree);
 232 static char *constructor_circularity_msg (tree, tree);
 233 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
 234 static const char *get_printable_method_name (tree);
 235 static tree patch_conditional_expr (tree, tree, tree);
 236 static tree generate_finit (tree);
 237 static tree generate_instinit (tree);
 238 static tree build_instinit_invocation (tree);
 239 static void fix_constructors (tree);
 240 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
 241 static tree craft_constructor (tree, tree);
 242 static int verify_constructor_super (tree);
 243 static tree create_artificial_method (tree, int, tree, tree, tree);
 244 static void start_artificial_method_body (tree);
 245 static void end_artificial_method_body (tree);
 246 static int check_method_redefinition (tree, tree);
 247 static int check_method_types_complete (tree);
 248 static bool hack_is_accessible_p (tree, tree);
 249 static void java_check_regular_methods (tree);
 250 static void check_interface_throws_clauses (tree, tree);
 251 static void java_check_abstract_methods (tree);
 252 static void unreachable_stmt_error (tree);
 253 static int not_accessible_field_error (tree, tree);
 254 static tree find_expr_with_wfl (tree);
 255 static void missing_return_error (tree);
 256 static tree build_new_array_init (int, tree);
 257 static tree patch_new_array_init (tree, tree);
 258 static tree maybe_build_array_element_wfl (tree);
 259 static int array_constructor_check_entry (tree, tree);
 260 static const char *purify_type_name (const char *);
 261 static tree fold_constant_for_init (tree, tree);
 262 static tree strip_out_static_field_access_decl (tree);
 263 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
 264 static void static_ref_err (tree, tree, tree);
 265 static void parser_add_interface (tree, tree, tree);
 266 static void add_superinterfaces (tree, tree);
 267 static tree jdep_resolve_class (jdep *);
 268 static int note_possible_classname (const char *, int);
 269 static void java_complete_expand_classes (void);
 270 static void java_complete_expand_class (tree);
 271 static void java_complete_expand_methods (tree);
 272 static tree cut_identifier_in_qualified (tree);
 273 static tree java_stabilize_reference (tree);
 274 static tree do_unary_numeric_promotion (tree);
 275 static char * operator_string (tree);
 276 static tree do_merge_string_cste (tree, const char *, int, int);
 277 static tree merge_string_cste (tree, tree, int);
 278 static tree java_refold (tree);
 279 static int java_decl_equiv (tree, tree);
 280 static int binop_compound_p (enum tree_code);
 281 static tree search_loop (tree);
 282 static int labeled_block_contains_loop_p (tree, tree);
 283 static int check_abstract_method_definitions (int, tree, tree);
 284 static void java_check_abstract_method_definitions (tree);
 285 static void java_debug_context_do (int);
 286 static void java_parser_context_push_initialized_field (void);
 287 static void java_parser_context_pop_initialized_field (void);
 288 static tree reorder_static_initialized (tree);
 289 static void java_parser_context_suspend (void);
 290 static void java_parser_context_resume (void);
 291 static int pop_current_osb (struct parser_ctxt *);
 292
 293 /* JDK 1.1 work. FIXME */
 294
 295 static tree maybe_make_nested_class_name (tree);
 296 static int make_nested_class_name (tree);
 297 static void set_nested_class_simple_name_value (tree, int);
 298 static void link_nested_class_to_enclosing (void);
 299 static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
 300 static tree find_as_inner_class (tree, tree, tree);
 301 static tree find_as_inner_class_do (tree, tree);
 302 static int check_inner_class_redefinition (tree, tree);
 303
 304 static tree build_thisn_assign (void);
 305 static tree build_current_thisn (tree);
 306 static tree build_access_to_thisn (tree, tree, int);
 307 static tree maybe_build_thisn_access_method (tree);
 308
 309 static tree build_outer_field_access (tree, tree);
 310 static tree build_outer_field_access_methods (tree);
 311 static tree build_outer_field_access_expr (int, tree, tree,
 312                                                   tree, tree);
 313 static tree build_outer_method_access_method (tree);
 314 static tree build_new_access_id (void);
 315 static tree build_outer_field_access_method (tree, tree, tree,
 316                                                     tree, tree);
 317
 318 static int outer_field_access_p (tree, tree);
 319 static int outer_field_expanded_access_p (tree, tree *,
 320                                                  tree *, tree *);
 321 static tree outer_field_access_fix (tree, tree, tree);
 322 static tree build_incomplete_class_ref (int, tree);
 323 static tree patch_incomplete_class_ref (tree);
 324 static tree create_anonymous_class (int, tree);
 325 static void patch_anonymous_class (tree, tree, tree);
 326 static void add_inner_class_fields (tree, tree);
 327
 328 static tree build_dot_class_method (tree);
 329 static tree build_dot_class_method_invocation (tree, tree);
 330 static void create_new_parser_context (int);
 331 static tree maybe_build_class_init_for_field (tree, tree);
 332
 333 static int attach_init_test_initialization_flags (void **, void *);
 334 static int emit_test_initialization (void **, void *);
 335
 336 static char *string_convert_int_cst (tree);
 337
 338 /* Number of error found so far. */
 339 int java_error_count;
 340 /* Number of warning found so far. */
 341 int java_warning_count;
 342 /* Tell when not to fold, when doing xrefs */
 343 int do_not_fold;
 344 /* Cyclic inheritance report, as it can be set by layout_class */
 345 const char *cyclic_inheritance_report;
 346
 347 /* The current parser context */
 348 struct parser_ctxt *ctxp;
 349
 350 /* List of things that were analyzed for which code will be generated */
 351 struct parser_ctxt *ctxp_for_generation = NULL;
 352
 353 /* binop_lookup maps token to tree_code. It is used where binary
 354    operations are involved and required by the parser. RDIV_EXPR
 355    covers both integral/floating point division. The code is changed
 356    once the type of both operator is worked out.  */
 357
 358 static const enum tree_code binop_lookup[19] =
 359   {
 360     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
 361     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
 362     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
 363     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
 364     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
 365    };
 366 #define BINOP_LOOKUP(VALUE)                                             \
 367   binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
 368
 369 /* This is the end index for binary operators that can also be used
 370    in compound assignments. */
 371 #define BINOP_COMPOUND_CANDIDATES 11
 372
 373 /* The "$L" identifier we use to create labels.  */
 374 static GTY(()) tree label_id;
 375
 376 /* The "StringBuffer" identifier used for the String `+' operator. */
 377 static GTY(()) tree wfl_string_buffer;
 378
 379 /* The "append" identifier used for String `+' operator.  */
 380 static GTY(()) tree wfl_append;
 381
 382 /* The "toString" identifier used for String `+' operator. */
 383 static GTY(()) tree wfl_to_string;
 384
 385 /* The "java.lang" import qualified name.  */
 386 static GTY(()) tree java_lang_id;
 387
 388 /* The generated `inst$' identifier used for generated enclosing
 389    instance/field access functions.  */
 390 static GTY(()) tree inst_id;
 391
 392 /* Context and flag for static blocks */
 393 static GTY(()) tree current_static_block;
 394
 395 /* The generated `write_parm_value$' identifier.  */
 396 static GTY(()) tree wpv_id;
 397
 398 /* The list of all packages we've seen so far */
 399 static GTY(()) tree package_list;
 400
 401 /* Hold THIS for the scope of the current method decl.  */
 402 static GTY(()) tree current_this;
 403
 404 /* Hold a list of catch clauses list. The first element of this list is
 405    the list of the catch clauses of the currently analyzed try block. */
 406 static GTY(()) tree currently_caught_type_list;
 407
 408 /* This holds a linked list of all the case labels for the current
 409    switch statement.  It is only used when checking to see if there
 410    are duplicate labels.  FIXME: probably this should just be attached
 411    to the switch itself; then it could be referenced via
 412    `ctxp->current_loop'.  */
 413 static GTY(()) tree case_label_list;
 414
 415 /* Anonymous class counter. Will be reset to 1 every time a non
 416    anonymous class gets created. */
 417 static int anonymous_class_counter = 1;
 418
 419 static GTY(()) tree src_parse_roots[1];
 420
 421 /* All classes seen from source code */
 422 #define gclass_list src_parse_roots[0]
 423
 424 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
 425    line and point it out.  */
 426 /* Should point out the one that don't fit. ASCII/unicode, going
 427    backward. FIXME */
 428
 429 #define check_modifiers(__message, __value, __mask) do {        \
 430   if ((__value) & ~(__mask))                                    \
 431     {                                                           \
 432       size_t i, remainder = (__value) & ~(__mask);              \
 433       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)     \
 434         if ((1 << i) & remainder)                               \
 435           parse_error_context (ctxp->modifier_ctx [i], (__message), \
 436                                java_accstring_lookup (1 << i)); \
 437     }                                                           \
 438 } while (0)
 439
 440 %}
 441
 442 %union {
 443   tree node;
 444   int sub_token;
 445   struct {
 446     int token;
 447     int location;
 448   } operator;
 449   int value;
 450 }
 451
 452 %{
 453 #include "lex.c"
 454 %}
 455
 456 %pure_parser
 457
 458 /* Things defined here have to match the order of what's in the
 459    binop_lookup table.  */
 460
 461 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
 462 %token   LS_TK           SRS_TK          ZRS_TK
 463 %token   AND_TK          XOR_TK          OR_TK
 464 %token   BOOL_AND_TK BOOL_OR_TK
 465 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
 466
 467 /* This maps to the same binop_lookup entry than the token above */
 468
 469 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
 470 %token   REM_ASSIGN_TK
 471 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 472 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
 473
 474
 475 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
 476
 477 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
 478 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
 479 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
 480 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
 481 %token   MODIFIER_TK
 482
 483 /* Keep those two in order, too */
 484 %token   DECR_TK INCR_TK
 485
 486 /* From now one, things can be in any order */
 487
 488 %token   DEFAULT_TK      IF_TK              THROW_TK
 489 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
 490 %token   THROWS_TK       BREAK_TK           IMPORT_TK
 491 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
 492 %token   VOID_TK         CATCH_TK           INTERFACE_TK
 493 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
 494 %token   SUPER_TK        WHILE_TK           CLASS_TK
 495 %token   SWITCH_TK       CONST_TK           TRY_TK
 496 %token   FOR_TK          NEW_TK             CONTINUE_TK
 497 %token   GOTO_TK         PACKAGE_TK         THIS_TK
 498 %token   ASSERT_TK
 499
 500 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
 501 %token   CHAR_TK         INTEGRAL_TK
 502
 503 %token   FLOAT_TK        DOUBLE_TK          FP_TK
 504
 505 %token   ID_TK
 506
 507 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
 508
 509 %token   ASSIGN_ANY_TK   ASSIGN_TK
 510 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
 511
 512 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
 513 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
 514
 515 %type    <value>        modifiers MODIFIER_TK final synchronized
 516
 517 %type    <node>         super ID_TK identifier
 518 %type    <node>         name simple_name qualified_name
 519 %type    <node>         type_declaration compilation_unit
 520                         field_declaration method_declaration extends_interfaces
 521                         interfaces interface_type_list
 522                         import_declarations package_declaration
 523                         type_declarations interface_body
 524                         interface_member_declaration constant_declaration
 525                         interface_member_declarations interface_type
 526                         abstract_method_declaration
 527 %type    <node>         class_body_declaration class_member_declaration
 528                         static_initializer constructor_declaration block
 529 %type    <node>         class_body_declarations constructor_header
 530 %type    <node>         class_or_interface_type class_type class_type_list
 531                         constructor_declarator explicit_constructor_invocation
 532 %type    <node>         dim_expr dim_exprs this_or_super throws
 533
 534 %type    <node>         variable_declarator_id variable_declarator
 535                         variable_declarators variable_initializer
 536                         variable_initializers constructor_body
 537                         array_initializer
 538
 539 %type    <node>         class_body block_end constructor_block_end
 540 %type    <node>         statement statement_without_trailing_substatement
 541                         labeled_statement if_then_statement label_decl
 542                         if_then_else_statement while_statement for_statement
 543                         statement_nsi labeled_statement_nsi do_statement
 544                         if_then_else_statement_nsi while_statement_nsi
 545                         for_statement_nsi statement_expression_list for_init
 546                         for_update statement_expression expression_statement
 547                         primary_no_new_array expression primary
 548                         array_creation_expression array_type
 549                         class_instance_creation_expression field_access
 550                         method_invocation array_access something_dot_new
 551                         argument_list postfix_expression while_expression
 552                         post_increment_expression post_decrement_expression
 553                         unary_expression_not_plus_minus unary_expression
 554                         pre_increment_expression pre_decrement_expression
 555                         cast_expression
 556                         multiplicative_expression additive_expression
 557                         shift_expression relational_expression
 558                         equality_expression and_expression
 559                         exclusive_or_expression inclusive_or_expression
 560                         conditional_and_expression conditional_or_expression
 561                         conditional_expression assignment_expression
 562                         left_hand_side assignment for_header for_begin
 563                         constant_expression do_statement_begin empty_statement
 564                         switch_statement synchronized_statement throw_statement
 565                         try_statement assert_statement
 566                         switch_expression switch_block
 567                         catches catch_clause catch_clause_parameter finally
 568                         anonymous_class_creation trap_overflow_corner_case
 569 %type    <node>         return_statement break_statement continue_statement
 570
 571 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
 572 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
 573 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 574 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
 575 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
 576 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
 577 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
 578 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
 579 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
 580 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
 581 %type    <operator>     THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
 582 %type    <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
 583 %type    <operator>     NEW_TK ASSERT_TK
 584
 585 %type    <node>         method_body
 586
 587 %type    <node>         literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
 588                         STRING_LIT_TK NULL_TK VOID_TK
 589
 590 %type    <node>         IF_TK WHILE_TK FOR_TK
 591
 592 %type    <node>         formal_parameter_list formal_parameter
 593                         method_declarator method_header
 594
 595 %type    <node>         primitive_type reference_type type
 596                         BOOLEAN_TK INTEGRAL_TK FP_TK
 597
 598 /* Added or modified JDK 1.1 rule types  */
 599 %type    <node>         type_literals
 600
 601 %%
 602 /* 19.2 Production from 2.3: The Syntactic Grammar  */
 603 goal:  compilation_unit
 604                 {}
 605 ;
 606
 607 /* 19.3 Productions from 3: Lexical structure  */
 608 literal:
 609         INT_LIT_TK
 610 |       FP_LIT_TK
 611 |       BOOL_LIT_TK
 612 |       CHAR_LIT_TK
 613 |       STRING_LIT_TK
 614 |       NULL_TK
 615 ;
 616
 617 /* 19.4 Productions from 4: Types, Values and Variables  */
 618 type:
 619         primitive_type
 620 |       reference_type
 621 ;
 622
 623 primitive_type:
 624         INTEGRAL_TK
 625 |       FP_TK
 626 |       BOOLEAN_TK
 627 ;
 628
 629 reference_type:
 630         class_or_interface_type
 631 |       array_type
 632 ;
 633
 634 class_or_interface_type:
 635         name
 636 ;
 637
 638 class_type:
 639         class_or_interface_type /* Default rule */
 640 ;
 641
 642 interface_type:
 643          class_or_interface_type
 644 ;
 645
 646 array_type:
 647         primitive_type dims
 648                 {
 649                   int osb = pop_current_osb (ctxp);
 650                   tree t = build_java_array_type (($1), -1);
 651                   while (--osb)
 652                     t = build_unresolved_array_type (t);
 653                   $$ = t;
 654                 }
 655 |       name dims
 656                 {
 657                   int osb = pop_current_osb (ctxp);
 658                   tree t = $1;
 659                   while (osb--)
 660                     t = build_unresolved_array_type (t);
 661                   $$ = t;
 662                 }
 663 ;
 664
 665 /* 19.5 Productions from 6: Names  */
 666 name:
 667         simple_name             /* Default rule */
 668 |       qualified_name          /* Default rule */
 669 ;
 670
 671 simple_name:
 672         identifier              /* Default rule */
 673 ;
 674
 675 qualified_name:
 676         name DOT_TK identifier
 677                 { $$ = make_qualified_name ($1, $3, $2.location); }
 678 ;
 679
 680 identifier:
 681         ID_TK
 682 ;
 683
 684 /* 19.6: Production from 7: Packages  */
 685 compilation_unit:
 686                 {$$ = NULL;}
 687 |       package_declaration
 688 |       import_declarations
 689 |       type_declarations
 690 |       package_declaration import_declarations
 691 |       package_declaration type_declarations
 692 |       import_declarations type_declarations
 693 |       package_declaration import_declarations type_declarations
 694 ;
 695
 696 import_declarations:
 697         import_declaration
 698                 {
 699                   $$ = NULL;
 700                 }
 701 |       import_declarations import_declaration
 702                 {
 703                   $$ = NULL;
 704                 }
 705 ;
 706
 707 type_declarations:
 708         type_declaration
 709 |       type_declarations type_declaration
 710 ;
 711
 712 package_declaration:
 713         PACKAGE_TK name SC_TK
 714                 {
 715                   ctxp->package = EXPR_WFL_NODE ($2);
 716                   register_package (ctxp->package);
 717                 }
 718 |       PACKAGE_TK error
 719                 {yyerror ("Missing name"); RECOVER;}
 720 |       PACKAGE_TK name error
 721                 {yyerror ("';' expected"); RECOVER;}
 722 ;
 723
 724 import_declaration:
 725         single_type_import_declaration
 726 |       type_import_on_demand_declaration
 727 ;
 728
 729 single_type_import_declaration:
 730         IMPORT_TK name SC_TK
 731                 {
 732                   tree name = EXPR_WFL_NODE ($2), last_name;
 733                   int   i = IDENTIFIER_LENGTH (name)-1;
 734                   const char *last = &IDENTIFIER_POINTER (name)[i];
 735                   while (last != IDENTIFIER_POINTER (name))
 736                     {
 737                       if (last [0] == '.')
 738                         break;
 739                       last--;
 740                     }
 741                   last_name = get_identifier (++last);
 742                   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
 743                     {
 744                       tree err = find_name_in_single_imports (last_name);
 745                       if (err && err != name)
 746                         parse_error_context
 747                           ($2, "Ambiguous class: `%s' and `%s'",
 748                            IDENTIFIER_POINTER (name),
 749                            IDENTIFIER_POINTER (err));
 750                       else
 751                         REGISTER_IMPORT ($2, last_name);
 752                     }
 753                   else
 754                     REGISTER_IMPORT ($2, last_name);
 755                 }
 756 |       IMPORT_TK error
 757                 {yyerror ("Missing name"); RECOVER;}
 758 |       IMPORT_TK name error
 759                 {yyerror ("';' expected"); RECOVER;}
 760 ;
 761
 762 type_import_on_demand_declaration:
 763         IMPORT_TK name DOT_TK MULT_TK SC_TK
 764                 {
 765                   tree name = EXPR_WFL_NODE ($2);
 766                   tree it;
 767                   /* Search for duplicates. */
 768                   for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
 769                     if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
 770                       break;
 771                   /* Don't import the same thing more than once, just ignore
 772                      duplicates (7.5.2) */
 773                   if (! it)
 774                     {
 775                       read_import_dir ($2);
 776                       ctxp->import_demand_list =
 777                         chainon (ctxp->import_demand_list,
 778                                  build_tree_list ($2, NULL_TREE));
 779                     }
 780                 }
 781 |       IMPORT_TK name DOT_TK error
 782                 {yyerror ("'*' expected"); RECOVER;}
 783 |       IMPORT_TK name DOT_TK MULT_TK error
 784                 {yyerror ("';' expected"); RECOVER;}
 785 ;
 786
 787 type_declaration:
 788         class_declaration
 789                 { end_class_declaration (0); }
 790 |       interface_declaration
 791                 { end_class_declaration (0); }
 792 |       empty_statement
 793 |       error
 794                 {
 795                   YYERROR_NOW;
 796                   yyerror ("Class or interface declaration expected");
 797                 }
 798 ;
 799
 800 /* 19.7 Shortened from the original:
 801    modifiers: modifier | modifiers modifier
 802    modifier: any of public...  */
 803 modifiers:
 804         MODIFIER_TK
 805                 {
 806                   $$ = (1 << $1);
 807                 }
 808 |       modifiers MODIFIER_TK
 809                 {
 810                   int acc = (1 << $2);
 811                   if ($$ & acc)
 812                     parse_error_context
 813                       (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
 814                        java_accstring_lookup (acc));
 815                   else
 816                     {
 817                       $$ |= acc;
 818                     }
 819                 }
 820 ;
 821
 822 /* 19.8.1 Production from $8.1: Class Declaration */
 823 class_declaration:
 824         modifiers CLASS_TK identifier super interfaces
 825                 { create_class ($1, $3, $4, $5); }
 826         class_body
 827                 {;}
 828 |       CLASS_TK identifier super interfaces
 829                 { create_class (0, $2, $3, $4); }
 830         class_body
 831                 {;}
 832 |       modifiers CLASS_TK error
 833                 { yyerror ("Missing class name"); RECOVER; }
 834 |       CLASS_TK error
 835                 { yyerror ("Missing class name"); RECOVER; }
 836 |       CLASS_TK identifier error
 837                 {
 838                   if (!ctxp->class_err) yyerror ("'{' expected");
 839                   DRECOVER(class1);
 840                 }
 841 |       modifiers CLASS_TK identifier error
 842                 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
 843 ;
 844
 845 super:
 846                 { $$ = NULL; }
 847 |       EXTENDS_TK class_type
 848                 { $$ = $2; }
 849 |       EXTENDS_TK class_type error
 850                 {yyerror ("'{' expected"); ctxp->class_err=1;}
 851 |       EXTENDS_TK error
 852                 {yyerror ("Missing super class name"); ctxp->class_err=1;}
 853 ;
 854
 855 interfaces:
 856                 { $$ = NULL_TREE; }
 857 |       IMPLEMENTS_TK interface_type_list
 858                 { $$ = $2; }
 859 |       IMPLEMENTS_TK error
 860                 {
 861                   ctxp->class_err=1;
 862                   yyerror ("Missing interface name");
 863                 }
 864 ;
 865
 866 interface_type_list:
 867         interface_type
 868                 {
 869                   ctxp->interface_number = 1;
 870                   $$ = build_tree_list ($1, NULL_TREE);
 871                 }
 872 |       interface_type_list C_TK interface_type
 873                 {
 874                   ctxp->interface_number++;
 875                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
 876                 }
 877 |       interface_type_list C_TK error
 878                 {yyerror ("Missing interface name"); RECOVER;}
 879 ;
 880
 881 class_body:
 882         OCB_TK CCB_TK
 883                 {
 884                   /* Store the location of the `}' when doing xrefs */
 885                   if (flag_emit_xref)
 886                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 887                       EXPR_WFL_ADD_COL ($2.location, 1);
 888                   $$ = GET_CPC ();
 889                 }
 890 |       OCB_TK class_body_declarations CCB_TK
 891                 {
 892                   /* Store the location of the `}' when doing xrefs */
 893                   if (flag_emit_xref)
 894                     DECL_END_SOURCE_LINE (GET_CPC ()) =
 895                       EXPR_WFL_ADD_COL ($3.location, 1);
 896                   $$ = GET_CPC ();
 897                 }
 898 ;
 899
 900 class_body_declarations:
 901         class_body_declaration
 902 |       class_body_declarations class_body_declaration
 903 ;
 904
 905 class_body_declaration:
 906         class_member_declaration
 907 |       static_initializer
 908 |       constructor_declaration
 909 |       block                   /* Added, JDK1.1, instance initializer */
 910                 {
 911                   if ($1 != empty_stmt_node)
 912                     {
 913                       TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
 914                       SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
 915                     }
 916                 }
 917 ;
 918
 919 class_member_declaration:
 920         field_declaration
 921 |       method_declaration
 922 |       class_declaration       /* Added, JDK1.1 inner classes */
 923                 { end_class_declaration (1); }
 924 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
 925                 { end_class_declaration (1); }
 926 |       empty_statement
 927 ;
 928
 929 /* 19.8.2 Productions from 8.3: Field Declarations  */
 930 field_declaration:
 931         type variable_declarators SC_TK
 932                 { register_fields (0, $1, $2); }
 933 |       modifiers type variable_declarators SC_TK
 934                 {
 935                   check_modifiers
 936                     ("Illegal modifier `%s' for field declaration",
 937                      $1, FIELD_MODIFIERS);
 938                   check_modifiers_consistency ($1);
 939                   register_fields ($1, $2, $3);
 940                 }
 941 ;
 942
 943 variable_declarators:
 944         /* Should we use build_decl_list () instead ? FIXME */
 945         variable_declarator     /* Default rule */
 946 |       variable_declarators C_TK variable_declarator
 947                 { $$ = chainon ($1, $3); }
 948 |       variable_declarators C_TK error
 949                 {yyerror ("Missing term"); RECOVER;}
 950 ;
 951
 952 variable_declarator:
 953         variable_declarator_id
 954                 { $$ = build_tree_list ($1, NULL_TREE); }
 955 |       variable_declarator_id ASSIGN_TK variable_initializer
 956                 {
 957                   if (java_error_count)
 958                     $3 = NULL_TREE;
 959                   $$ = build_tree_list
 960                     ($1, build_assignment ($2.token, $2.location, $1, $3));
 961                 }
 962 |       variable_declarator_id ASSIGN_TK error
 963                 {
 964                   yyerror ("Missing variable initializer");
 965                   $$ = build_tree_list ($1, NULL_TREE);
 966                   RECOVER;
 967                 }
 968 |       variable_declarator_id ASSIGN_TK variable_initializer error
 969                 {
 970                   yyerror ("';' expected");
 971                   $$ = build_tree_list ($1, NULL_TREE);
 972                   RECOVER;
 973                 }
 974 ;
 975
 976 variable_declarator_id:
 977         identifier
 978 |       variable_declarator_id OSB_TK CSB_TK
 979                 { $$ = build_unresolved_array_type ($1); }
 980 |       identifier error
 981                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
 982 |       variable_declarator_id OSB_TK error
 983                 {
 984                   yyerror ("']' expected");
 985                   DRECOVER(vdi);
 986                 }
 987 |       variable_declarator_id CSB_TK error
 988                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
 989 ;
 990
 991 variable_initializer:
 992         expression
 993 |       array_initializer
 994 ;
 995
 996 /* 19.8.3 Productions from 8.4: Method Declarations  */
 997 method_declaration:
 998         method_header
 999                 {
1000                   current_function_decl = $1;
1001                   if (current_function_decl
1002                       && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1003                     source_start_java_method (current_function_decl);
1004                   else
1005                     current_function_decl = NULL_TREE;
1006                 }
1007         method_body
1008                 { finish_method_declaration ($3); }
1009 |       method_header error
1010                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1011 ;
1012
1013 method_header:
1014         type method_declarator throws
1015                 { $$ = method_header (0, $1, $2, $3); }
1016 |       VOID_TK method_declarator throws
1017                 { $$ = method_header (0, void_type_node, $2, $3); }
1018 |       modifiers type method_declarator throws
1019                 { $$ = method_header ($1, $2, $3, $4); }
1020 |       modifiers VOID_TK method_declarator throws
1021                 { $$ = method_header ($1, void_type_node, $3, $4); }
1022 |       type error
1023                 {
1024                   yyerror ("Invalid method declaration, method name required");
1025                   RECOVER;
1026                 }
1027 |       modifiers type error
1028                 {
1029                   yyerror ("Identifier expected");
1030                   RECOVER;
1031                 }
1032 |       VOID_TK error
1033                 {
1034                   yyerror ("Identifier expected");
1035                   RECOVER;
1036                 }
1037 |       modifiers VOID_TK error
1038                 {
1039                   yyerror ("Identifier expected");
1040                   RECOVER;
1041                 }
1042 |       modifiers error
1043                 {
1044                   yyerror ("Invalid method declaration, return type required");
1045                   RECOVER;
1046                 }
1047 ;
1048
1049 method_declarator:
1050         identifier OP_TK CP_TK
1051                 {
1052                   ctxp->formal_parameter_number = 0;
1053                   $$ = method_declarator ($1, NULL_TREE);
1054                 }
1055 |       identifier OP_TK formal_parameter_list CP_TK
1056                 { $$ = method_declarator ($1, $3); }
1057 |       method_declarator OSB_TK CSB_TK
1058                 {
1059                   EXPR_WFL_LINECOL (wfl_operator) = $2.location;
1060                   TREE_PURPOSE ($1) =
1061                     build_unresolved_array_type (TREE_PURPOSE ($1));
1062                   parse_warning_context
1063                     (wfl_operator,
1064                      "Discouraged form of returned type specification");
1065                 }
1066 |       identifier OP_TK error
1067                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1068 |       method_declarator OSB_TK error
1069                 {yyerror ("']' expected"); RECOVER;}
1070 ;
1071
1072 formal_parameter_list:
1073         formal_parameter
1074                 {
1075                   ctxp->formal_parameter_number = 1;
1076                 }
1077 |       formal_parameter_list C_TK formal_parameter
1078                 {
1079                   ctxp->formal_parameter_number += 1;
1080                   $$ = chainon ($1, $3);
1081                 }
1082 |       formal_parameter_list C_TK error
1083                 { yyerror ("Missing formal parameter term"); RECOVER; }
1084 ;
1085
1086 formal_parameter:
1087         type variable_declarator_id
1088                 {
1089                   $$ = build_tree_list ($2, $1);
1090                 }
1091 |       final type variable_declarator_id /* Added, JDK1.1 final parms */
1092                 {
1093                   $$ = build_tree_list ($3, $2);
1094                   ARG_FINAL_P ($$) = 1;
1095                 }
1096 |       type error
1097                 {
1098                   yyerror ("Missing identifier"); RECOVER;
1099                   $$ = NULL_TREE;
1100                 }
1101 |       final type error
1102                 {
1103                   yyerror ("Missing identifier"); RECOVER;
1104                   $$ = NULL_TREE;
1105                 }
1106 ;
1107
1108 final:
1109         modifiers
1110                 {
1111                   check_modifiers ("Illegal modifier `%s'. Only `final' was expected here",
1112                                    $1, ACC_FINAL);
1113                   if ($1 != ACC_FINAL)
1114                     MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1115                 }
1116 ;
1117
1118 throws:
1119                 { $$ = NULL_TREE; }
1120 |       THROWS_TK class_type_list
1121                 { $$ = $2; }
1122 |       THROWS_TK error
1123                 {yyerror ("Missing class type term"); RECOVER;}
1124 ;
1125
1126 class_type_list:
1127         class_type
1128                 { $$ = build_tree_list ($1, $1); }
1129 |       class_type_list C_TK class_type
1130                 { $$ = tree_cons ($3, $3, $1); }
1131 |       class_type_list C_TK error
1132                 {yyerror ("Missing class type term"); RECOVER;}
1133 ;
1134
1135 method_body:
1136         block
1137 |       SC_TK { $$ = NULL_TREE; }
1138 ;
1139
1140 /* 19.8.4 Productions from 8.5: Static Initializers  */
1141 static_initializer:
1142         static block
1143                 {
1144                   TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1145                   SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1146                   current_static_block = NULL_TREE;
1147                 }
1148 ;
1149
1150 static:                         /* Test lval.sub_token here */
1151         modifiers
1152                 {
1153                   check_modifiers ("Illegal modifier `%s' for static initializer", $1, ACC_STATIC);
1154                   /* Can't have a static initializer in an innerclass */
1155                   if ($1 | ACC_STATIC &&
1156                       GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1157                     parse_error_context
1158                       (MODIFIER_WFL (STATIC_TK),
1159                        "Can't define static initializer in class `%s'. Static initializer can only be defined in top-level classes",
1160                        IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1161                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1162                 }
1163 ;
1164
1165 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1166 constructor_declaration:
1167         constructor_header
1168                 {
1169                   current_function_decl = $1;
1170                   source_start_java_method (current_function_decl);
1171                 }
1172         constructor_body
1173                 { finish_method_declaration ($3); }
1174 ;
1175
1176 constructor_header:
1177         constructor_declarator throws
1178                 { $$ = method_header (0, NULL_TREE, $1, $2); }
1179 |       modifiers constructor_declarator throws
1180                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1181 ;
1182
1183 constructor_declarator:
1184         simple_name OP_TK CP_TK
1185                 {
1186                   ctxp->formal_parameter_number = 0;
1187                   $$ = method_declarator ($1, NULL_TREE);
1188                 }
1189 |       simple_name OP_TK formal_parameter_list CP_TK
1190                 { $$ = method_declarator ($1, $3); }
1191 ;
1192
1193 constructor_body:
1194         /* Unlike regular method, we always need a complete (empty)
1195            body so we can safely perform all the required code
1196            addition (super invocation and field initialization) */
1197         block_begin constructor_block_end
1198                 {
1199                   BLOCK_EXPR_BODY ($2) = empty_stmt_node;
1200                   $$ = $2;
1201                 }
1202 |       block_begin explicit_constructor_invocation constructor_block_end
1203                 { $$ = $3; }
1204 |       block_begin block_statements constructor_block_end
1205                 { $$ = $3; }
1206 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1207                 { $$ = $4; }
1208 ;
1209
1210 constructor_block_end:
1211         block_end
1212 ;
1213
1214 /* Error recovery for that rule moved down expression_statement: rule.  */
1215 explicit_constructor_invocation:
1216         this_or_super OP_TK CP_TK SC_TK
1217                 {
1218                   $$ = build_method_invocation ($1, NULL_TREE);
1219                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1220                   $$ = java_method_add_stmt (current_function_decl, $$);
1221                 }
1222 |       this_or_super OP_TK argument_list CP_TK SC_TK
1223                 {
1224                   $$ = build_method_invocation ($1, $3);
1225                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1226                   $$ = java_method_add_stmt (current_function_decl, $$);
1227                 }
1228         /* Added, JDK1.1 inner classes. Modified because the rule
1229            'primary' couldn't work.  */
1230 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1231                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1232 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1233                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1234 ;
1235
1236 this_or_super:                  /* Added, simplifies error diagnostics */
1237         THIS_TK
1238                 {
1239                   tree wfl = build_wfl_node (this_identifier_node);
1240                   EXPR_WFL_LINECOL (wfl) = $1.location;
1241                   $$ = wfl;
1242                 }
1243 |       SUPER_TK
1244                 {
1245                   tree wfl = build_wfl_node (super_identifier_node);
1246                   EXPR_WFL_LINECOL (wfl) = $1.location;
1247                   $$ = wfl;
1248                 }
1249 ;
1250
1251 /* 19.9 Productions from 9: Interfaces  */
1252 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1253 interface_declaration:
1254         INTERFACE_TK identifier
1255                 { create_interface (0, $2, NULL_TREE); }
1256         interface_body
1257                 { ; }
1258 |       modifiers INTERFACE_TK identifier
1259                 { create_interface ($1, $3, NULL_TREE); }
1260         interface_body
1261                 { ; }
1262 |       INTERFACE_TK identifier extends_interfaces
1263                 { create_interface (0, $2, $3); }
1264         interface_body
1265                 { ; }
1266 |       modifiers INTERFACE_TK identifier extends_interfaces
1267                 { create_interface ($1, $3, $4); }
1268         interface_body
1269                 { ; }
1270 |       INTERFACE_TK identifier error
1271                 { yyerror ("'{' expected"); RECOVER; }
1272 |       modifiers INTERFACE_TK identifier error
1273                 { yyerror ("'{' expected"); RECOVER; }
1274 ;
1275
1276 extends_interfaces:
1277         EXTENDS_TK interface_type
1278                 {
1279                   ctxp->interface_number = 1;
1280                   $$ = build_tree_list ($2, NULL_TREE);
1281                 }
1282 |       extends_interfaces C_TK interface_type
1283                 {
1284                   ctxp->interface_number++;
1285                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1286                 }
1287 |       EXTENDS_TK error
1288                 {yyerror ("Invalid interface type"); RECOVER;}
1289 |       extends_interfaces C_TK error
1290                 {yyerror ("Missing term"); RECOVER;}
1291 ;
1292
1293 interface_body:
1294         OCB_TK CCB_TK
1295                 { $$ = NULL_TREE; }
1296 |       OCB_TK interface_member_declarations CCB_TK
1297                 { $$ = NULL_TREE; }
1298 ;
1299
1300 interface_member_declarations:
1301         interface_member_declaration
1302 |       interface_member_declarations interface_member_declaration
1303 ;
1304
1305 interface_member_declaration:
1306         constant_declaration
1307 |       abstract_method_declaration
1308 |       class_declaration       /* Added, JDK1.1 inner classes */
1309                 { end_class_declaration (1); }
1310 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
1311                 { end_class_declaration (1); }
1312 ;
1313
1314 constant_declaration:
1315         field_declaration
1316 ;
1317
1318 abstract_method_declaration:
1319         method_header SC_TK
1320                 {
1321                   check_abstract_method_header ($1);
1322                   current_function_decl = NULL_TREE; /* FIXME ? */
1323                 }
1324 |       method_header error
1325                 {yyerror ("';' expected"); RECOVER;}
1326 ;
1327
1328 /* 19.10 Productions from 10: Arrays  */
1329 array_initializer:
1330         OCB_TK CCB_TK
1331                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1332 |       OCB_TK C_TK CCB_TK
1333                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1334 |       OCB_TK variable_initializers CCB_TK
1335                 { $$ = build_new_array_init ($1.location, $2); }
1336 |       OCB_TK variable_initializers C_TK CCB_TK
1337                 { $$ = build_new_array_init ($1.location, $2); }
1338 ;
1339
1340 variable_initializers:
1341         variable_initializer
1342                 {
1343                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1344                                   $1, NULL_TREE);
1345                 }
1346 |       variable_initializers C_TK variable_initializer
1347                 {
1348                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1349                 }
1350 |       variable_initializers C_TK error
1351                 {yyerror ("Missing term"); RECOVER;}
1352 ;
1353
1354 /* 19.11 Production from 14: Blocks and Statements  */
1355 block:
1356         block_begin block_end
1357                 { $$ = $2; }
1358 |       block_begin block_statements block_end
1359                 { $$ = $3; }
1360 ;
1361
1362 block_begin:
1363         OCB_TK
1364                 { enter_block (); }
1365 ;
1366
1367 block_end:
1368         CCB_TK
1369                 {
1370                   maybe_absorb_scoping_blocks ();
1371                   /* Store the location of the `}' when doing xrefs */
1372                   if (current_function_decl && flag_emit_xref)
1373                     DECL_END_SOURCE_LINE (current_function_decl) =
1374                       EXPR_WFL_ADD_COL ($1.location, 1);
1375                   $$ = exit_block ();
1376                   if (!BLOCK_SUBBLOCKS ($$))
1377                     BLOCK_SUBBLOCKS ($$) = empty_stmt_node;
1378                 }
1379 ;
1380
1381 block_statements:
1382         block_statement
1383 |       block_statements block_statement
1384 ;
1385
1386 block_statement:
1387         local_variable_declaration_statement
1388 |       statement
1389                 { java_method_add_stmt (current_function_decl, $1); }
1390 |       class_declaration       /* Added, JDK1.1 local classes */
1391                 {
1392                   LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1393                   end_class_declaration (1);
1394                 }
1395 ;
1396
1397 local_variable_declaration_statement:
1398         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1399 ;
1400
1401 local_variable_declaration:
1402         type variable_declarators
1403                 { declare_local_variables (0, $1, $2); }
1404 |       final type variable_declarators /* Added, JDK1.1 final locals */
1405                 { declare_local_variables ($1, $2, $3); }
1406 ;
1407
1408 statement:
1409         statement_without_trailing_substatement
1410 |       labeled_statement
1411 |       if_then_statement
1412 |       if_then_else_statement
1413 |       while_statement
1414 |       for_statement
1415                 { $$ = exit_block (); }
1416 ;
1417
1418 statement_nsi:
1419         statement_without_trailing_substatement
1420 |       labeled_statement_nsi
1421 |       if_then_else_statement_nsi
1422 |       while_statement_nsi
1423 |       for_statement_nsi
1424                 { $$ = exit_block (); }
1425 ;
1426
1427 statement_without_trailing_substatement:
1428         block
1429 |       empty_statement
1430 |       expression_statement
1431 |       switch_statement
1432 |       do_statement
1433 |       break_statement
1434 |       continue_statement
1435 |       return_statement
1436 |       synchronized_statement
1437 |       throw_statement
1438 |       try_statement
1439 |       assert_statement
1440 ;
1441
1442 empty_statement:
1443         SC_TK
1444                 {
1445                   if (flag_extraneous_semicolon
1446                       && ! current_static_block
1447                       && (! current_function_decl ||
1448                           /* Verify we're not in a inner class declaration */
1449                           (GET_CPC () != TYPE_NAME
1450                            (DECL_CONTEXT (current_function_decl)))))
1451
1452                     {
1453                       EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1454                       parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1455                     }
1456                   $$ = empty_stmt_node;
1457                 }
1458 ;
1459
1460 label_decl:
1461         identifier REL_CL_TK
1462                 {
1463                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1464                                             EXPR_WFL_NODE ($1));
1465                   pushlevel (2);
1466                   push_labeled_block ($$);
1467                   PUSH_LABELED_BLOCK ($$);
1468                 }
1469 ;
1470
1471 labeled_statement:
1472         label_decl statement
1473                 { $$ = finish_labeled_statement ($1, $2); }
1474 |       identifier error
1475                 {yyerror ("':' expected"); RECOVER;}
1476 ;
1477
1478 labeled_statement_nsi:
1479         label_decl statement_nsi
1480                 { $$ = finish_labeled_statement ($1, $2); }
1481 ;
1482
1483 /* We concentrate here a bunch of error handling rules that we couldn't write
1484    earlier, because expression_statement catches a missing ';'.  */
1485 expression_statement:
1486         statement_expression SC_TK
1487                 {
1488                   /* We have a statement. Generate a WFL around it so
1489                      we can debug it */
1490                   $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1491                   /* We know we have a statement, so set the debug
1492                      info to be eventually generate here. */
1493                   $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1494                 }
1495 |       error SC_TK
1496                 {
1497                   YYNOT_TWICE yyerror ("Invalid expression statement");
1498                   DRECOVER (expr_stmt);
1499                 }
1500 |       error OCB_TK
1501                 {
1502                   YYNOT_TWICE yyerror ("Invalid expression statement");
1503                   DRECOVER (expr_stmt);
1504                 }
1505 |       error CCB_TK
1506                 {
1507                   YYNOT_TWICE yyerror ("Invalid expression statement");
1508                   DRECOVER (expr_stmt);
1509                 }
1510 |       this_or_super OP_TK error
1511                 {yyerror ("')' expected"); RECOVER;}
1512 |       this_or_super OP_TK CP_TK error
1513                 {
1514                   parse_ctor_invocation_error ();
1515                   RECOVER;
1516                 }
1517 |       this_or_super OP_TK argument_list error
1518                 {yyerror ("')' expected"); RECOVER;}
1519 |       this_or_super OP_TK argument_list CP_TK error
1520                 {
1521                   parse_ctor_invocation_error ();
1522                   RECOVER;
1523                 }
1524 |       name DOT_TK SUPER_TK error
1525                 {yyerror ("'(' expected"); RECOVER;}
1526 |       name DOT_TK SUPER_TK OP_TK error
1527                 {yyerror ("')' expected"); RECOVER;}
1528 |       name DOT_TK SUPER_TK OP_TK argument_list error
1529                 {yyerror ("')' expected"); RECOVER;}
1530 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1531                 {yyerror ("';' expected"); RECOVER;}
1532 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1533                 {yyerror ("';' expected"); RECOVER;}
1534 ;
1535
1536 statement_expression:
1537         assignment
1538 |       pre_increment_expression
1539 |       pre_decrement_expression
1540 |       post_increment_expression
1541 |       post_decrement_expression
1542 |       method_invocation
1543 |       class_instance_creation_expression
1544 ;
1545
1546 if_then_statement:
1547         IF_TK OP_TK expression CP_TK statement
1548                 {
1549                   $$ = build_if_else_statement ($2.location, $3,
1550                                                 $5, NULL_TREE);
1551                 }
1552 |       IF_TK error
1553                 {yyerror ("'(' expected"); RECOVER;}
1554 |       IF_TK OP_TK error
1555                 {yyerror ("Missing term"); RECOVER;}
1556 |       IF_TK OP_TK expression error
1557                 {yyerror ("')' expected"); RECOVER;}
1558 ;
1559
1560 if_then_else_statement:
1561         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1562                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1563 ;
1564
1565 if_then_else_statement_nsi:
1566         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1567                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1568 ;
1569
1570 switch_statement:
1571         switch_expression
1572                 {
1573                   enter_block ();
1574                 }
1575         switch_block
1576                 {
1577                   /* Make into "proper list" of COMPOUND_EXPRs.
1578                      I.e. make the last statement also have its own
1579                      COMPOUND_EXPR. */
1580                   maybe_absorb_scoping_blocks ();
1581                   TREE_OPERAND ($1, 1) = exit_block ();
1582                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1583                 }
1584 ;
1585
1586 switch_expression:
1587         SWITCH_TK OP_TK expression CP_TK
1588                 {
1589                   $$ = build (SWITCH_EXPR, NULL_TREE, $3, NULL_TREE);
1590                   EXPR_WFL_LINECOL ($$) = $2.location;
1591                 }
1592 |       SWITCH_TK error
1593                 {yyerror ("'(' expected"); RECOVER;}
1594 |       SWITCH_TK OP_TK error
1595                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1596 |       SWITCH_TK OP_TK expression CP_TK error
1597                 {yyerror ("'{' expected"); RECOVER;}
1598 ;
1599
1600 /* Default assignment is there to avoid type node on switch_block
1601    node. */
1602
1603 switch_block:
1604         OCB_TK CCB_TK
1605                 { $$ = NULL_TREE; }
1606 |       OCB_TK switch_labels CCB_TK
1607                 { $$ = NULL_TREE; }
1608 |       OCB_TK switch_block_statement_groups CCB_TK
1609                 { $$ = NULL_TREE; }
1610 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1611                 { $$ = NULL_TREE; }
1612 ;
1613
1614 switch_block_statement_groups:
1615         switch_block_statement_group
1616 |       switch_block_statement_groups switch_block_statement_group
1617 ;
1618
1619 switch_block_statement_group:
1620         switch_labels block_statements
1621 ;
1622
1623 switch_labels:
1624         switch_label
1625 |       switch_labels switch_label
1626 ;
1627
1628 switch_label:
1629         CASE_TK constant_expression REL_CL_TK
1630                 {
1631                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1632                   EXPR_WFL_LINECOL (lab) = $1.location;
1633                   java_method_add_stmt (current_function_decl, lab);
1634                 }
1635 |       DEFAULT_TK REL_CL_TK
1636                 {
1637                   tree lab = build (DEFAULT_EXPR, NULL_TREE, NULL_TREE);
1638                   EXPR_WFL_LINECOL (lab) = $1.location;
1639                   java_method_add_stmt (current_function_decl, lab);
1640                 }
1641 |       CASE_TK error
1642                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1643 |       CASE_TK constant_expression error
1644                 {yyerror ("':' expected"); RECOVER;}
1645 |       DEFAULT_TK error
1646                 {yyerror ("':' expected"); RECOVER;}
1647 ;
1648
1649 while_expression:
1650         WHILE_TK OP_TK expression CP_TK
1651                 {
1652                   tree body = build_loop_body ($2.location, $3, 0);
1653                   $$ = build_new_loop (body);
1654                 }
1655 ;
1656
1657 while_statement:
1658         while_expression statement
1659                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1660 |       WHILE_TK error
1661                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1662 |       WHILE_TK OP_TK error
1663                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1664 |       WHILE_TK OP_TK expression error
1665                 {yyerror ("')' expected"); RECOVER;}
1666 ;
1667
1668 while_statement_nsi:
1669         while_expression statement_nsi
1670                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1671 ;
1672
1673 do_statement_begin:
1674         DO_TK
1675                 {
1676                   tree body = build_loop_body (0, NULL_TREE, 1);
1677                   $$ = build_new_loop (body);
1678                 }
1679         /* Need error handing here. FIXME */
1680 ;
1681
1682 do_statement:
1683         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1684                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1685 ;
1686
1687 for_statement:
1688         for_begin SC_TK expression SC_TK for_update CP_TK statement
1689                 {
1690                   if (TREE_CODE_CLASS (TREE_CODE ($3)) == 'c')
1691                     $3 = build_wfl_node ($3);
1692                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1693                 }
1694 |       for_begin SC_TK SC_TK for_update CP_TK statement
1695                 {
1696                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1697                   /* We have not condition, so we get rid of the EXIT_EXPR */
1698                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1699                     empty_stmt_node;
1700                 }
1701 |       for_begin SC_TK error
1702                 {yyerror ("Invalid control expression"); RECOVER;}
1703 |       for_begin SC_TK expression SC_TK error
1704                 {yyerror ("Invalid update expression"); RECOVER;}
1705 |       for_begin SC_TK SC_TK error
1706                 {yyerror ("Invalid update expression"); RECOVER;}
1707 ;
1708
1709 for_statement_nsi:
1710         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1711                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1712 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1713                 {
1714                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1715                   /* We have not condition, so we get rid of the EXIT_EXPR */
1716                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1717                     empty_stmt_node;
1718                 }
1719 ;
1720
1721 for_header:
1722         FOR_TK OP_TK
1723                 {
1724                   /* This scope defined for local variable that may be
1725                      defined within the scope of the for loop */
1726                   enter_block ();
1727                 }
1728 |       FOR_TK error
1729                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1730 |       FOR_TK OP_TK error
1731                 {yyerror ("Invalid init statement"); RECOVER;}
1732 ;
1733
1734 for_begin:
1735         for_header for_init
1736                 {
1737                   /* We now declare the loop body. The loop is
1738                      declared as a for loop. */
1739                   tree body = build_loop_body (0, NULL_TREE, 0);
1740                   $$ =  build_new_loop (body);
1741                   FOR_LOOP_P ($$) = 1;
1742                   /* The loop is added to the current block the for
1743                      statement is defined within */
1744                   java_method_add_stmt (current_function_decl, $$);
1745                 }
1746 ;
1747 for_init:                       /* Can be empty */
1748                 { $$ = empty_stmt_node; }
1749 |       statement_expression_list
1750                 {
1751                   /* Init statement recorded within the previously
1752                      defined block scope */
1753                   $$ = java_method_add_stmt (current_function_decl, $1);
1754                 }
1755 |       local_variable_declaration
1756                 {
1757                   /* Local variable are recorded within the previously
1758                      defined block scope */
1759                   $$ = NULL_TREE;
1760                 }
1761 |       statement_expression_list error
1762                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1763 ;
1764
1765 for_update:                     /* Can be empty */
1766                 {$$ = empty_stmt_node;}
1767 |       statement_expression_list
1768                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1769 ;
1770
1771 statement_expression_list:
1772         statement_expression
1773                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1774 |       statement_expression_list C_TK statement_expression
1775                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1776 |       statement_expression_list C_TK error
1777                 {yyerror ("Missing term"); RECOVER;}
1778 ;
1779
1780 break_statement:
1781         BREAK_TK SC_TK
1782                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1783 |       BREAK_TK identifier SC_TK
1784                 { $$ = build_bc_statement ($1.location, 1, $2); }
1785 |       BREAK_TK error
1786                 {yyerror ("Missing term"); RECOVER;}
1787 |       BREAK_TK identifier error
1788                 {yyerror ("';' expected"); RECOVER;}
1789 ;
1790
1791 continue_statement:
1792         CONTINUE_TK SC_TK
1793                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1794 |       CONTINUE_TK identifier SC_TK
1795                 { $$ = build_bc_statement ($1.location, 0, $2); }
1796 |       CONTINUE_TK error
1797                 {yyerror ("Missing term"); RECOVER;}
1798 |       CONTINUE_TK identifier error
1799                 {yyerror ("';' expected"); RECOVER;}
1800 ;
1801
1802 return_statement:
1803         RETURN_TK SC_TK
1804                 { $$ = build_return ($1.location, NULL_TREE); }
1805 |       RETURN_TK expression SC_TK
1806                 { $$ = build_return ($1.location, $2); }
1807 |       RETURN_TK error
1808                 {yyerror ("Missing term"); RECOVER;}
1809 |       RETURN_TK expression error
1810                 {yyerror ("';' expected"); RECOVER;}
1811 ;
1812
1813 throw_statement:
1814         THROW_TK expression SC_TK
1815                 {
1816                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1817                   EXPR_WFL_LINECOL ($$) = $1.location;
1818                 }
1819 |       THROW_TK error
1820                 {yyerror ("Missing term"); RECOVER;}
1821 |       THROW_TK expression error
1822                 {yyerror ("';' expected"); RECOVER;}
1823 ;
1824
1825 assert_statement:
1826         ASSERT_TK expression REL_CL_TK expression SC_TK
1827                 {
1828                   $$ = build_assertion ($1.location, $2, $4);
1829                 }
1830 |       ASSERT_TK expression SC_TK
1831                 {
1832                   $$ = build_assertion ($1.location, $2, NULL_TREE);
1833                 }
1834 |       ASSERT_TK error
1835                 {yyerror ("Missing term"); RECOVER;}
1836 |       ASSERT_TK expression error
1837                 {yyerror ("';' expected"); RECOVER;}
1838 ;
1839
1840 synchronized_statement:
1841         synchronized OP_TK expression CP_TK block
1842                 {
1843                   $$ = build (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1844                   EXPR_WFL_LINECOL ($$) =
1845                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1846                 }
1847 |       synchronized OP_TK expression CP_TK error
1848                 {yyerror ("'{' expected"); RECOVER;}
1849 |       synchronized error
1850                 {yyerror ("'(' expected"); RECOVER;}
1851 |       synchronized OP_TK error CP_TK
1852                 {yyerror ("Missing term"); RECOVER;}
1853 |       synchronized OP_TK error
1854                 {yyerror ("Missing term"); RECOVER;}
1855 ;
1856
1857 synchronized:
1858         modifiers
1859                 {
1860                   check_modifiers (
1861              "Illegal modifier `%s'. Only `synchronized' was expected here",
1862                                    $1, ACC_SYNCHRONIZED);
1863                   if ($1 != ACC_SYNCHRONIZED)
1864                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1865                       build_wfl_node (NULL_TREE);
1866                 }
1867 ;
1868
1869 try_statement:
1870         TRY_TK block catches
1871                 { $$ = build_try_statement ($1.location, $2, $3); }
1872 |       TRY_TK block finally
1873                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1874 |       TRY_TK block catches finally
1875                 { $$ = build_try_finally_statement
1876                     ($1.location, build_try_statement ($1.location,
1877                                                        $2, $3), $4);
1878                 }
1879 |       TRY_TK error
1880                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1881 ;
1882
1883 catches:
1884         catch_clause
1885 |       catches catch_clause
1886                 {
1887                   TREE_CHAIN ($2) = $1;
1888                   $$ = $2;
1889                 }
1890 ;
1891
1892 catch_clause:
1893         catch_clause_parameter block
1894                 {
1895                   java_method_add_stmt (current_function_decl, $2);
1896                   exit_block ();
1897                   $$ = $1;
1898                 }
1899 ;
1900
1901 catch_clause_parameter:
1902         CATCH_TK OP_TK formal_parameter CP_TK
1903                 {
1904                   /* We add a block to define a scope for
1905                      formal_parameter (CCBP). The formal parameter is
1906                      declared initialized by the appropriate function
1907                      call */
1908                   tree ccpb;
1909                   tree init;
1910                   if ($3)
1911                     {
1912                       ccpb = enter_block ();
1913                       init = build_assignment
1914                         (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1915                          build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1916                       declare_local_variables (0, TREE_VALUE ($3),
1917                                                build_tree_list
1918                                                (TREE_PURPOSE ($3), init));
1919                       $$ = build1 (CATCH_EXPR, NULL_TREE, ccpb);
1920                       EXPR_WFL_LINECOL ($$) = $1.location;
1921                     }
1922                   else
1923                     {
1924                       $$ = error_mark_node;
1925                     }
1926                 }
1927 |       CATCH_TK error
1928                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1929 |       CATCH_TK OP_TK error
1930                 {
1931                   yyerror ("Missing term or ')' expected");
1932                   RECOVER; $$ = NULL_TREE;
1933                 }
1934 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1935                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1936 ;
1937
1938 finally:
1939         FINALLY_TK block
1940                 { $$ = $2; }
1941 |       FINALLY_TK error
1942                 {yyerror ("'{' expected"); RECOVER; }
1943 ;
1944
1945 /* 19.12 Production from 15: Expressions  */
1946 primary:
1947         primary_no_new_array
1948 |       array_creation_expression
1949 ;
1950
1951 primary_no_new_array:
1952         literal
1953 |       THIS_TK
1954                 { $$ = build_this ($1.location); }
1955 |       OP_TK expression CP_TK
1956                 {$$ = $2;}
1957 |       class_instance_creation_expression
1958 |       field_access
1959 |       method_invocation
1960 |       array_access
1961 |       type_literals
1962         /* Added, JDK1.1 inner classes. Documentation is wrong
1963            refering to a 'ClassName' (class_name) rule that doesn't
1964            exist. Used name: instead.  */
1965 |       name DOT_TK THIS_TK
1966                 {
1967                   tree wfl = build_wfl_node (this_identifier_node);
1968                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1969                 }
1970 |       OP_TK expression error
1971                 {yyerror ("')' expected"); RECOVER;}
1972 |       name DOT_TK error
1973                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1974 |       primitive_type DOT_TK error
1975                 {yyerror ("'class' expected" ); RECOVER;}
1976 |       VOID_TK DOT_TK error
1977                 {yyerror ("'class' expected" ); RECOVER;}
1978 ;
1979
1980 type_literals:
1981         name DOT_TK CLASS_TK
1982                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1983 |       array_type DOT_TK CLASS_TK
1984                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1985 |       primitive_type DOT_TK CLASS_TK
1986                 { $$ = build_incomplete_class_ref ($2.location, $1); }
1987 |       VOID_TK DOT_TK CLASS_TK
1988                 {
1989                    $$ = build_incomplete_class_ref ($2.location,
1990                                                    void_type_node);
1991                 }
1992 ;
1993
1994 class_instance_creation_expression:
1995         NEW_TK class_type OP_TK argument_list CP_TK
1996                 { $$ = build_new_invocation ($2, $4); }
1997 |       NEW_TK class_type OP_TK CP_TK
1998                 { $$ = build_new_invocation ($2, NULL_TREE); }
1999 |       anonymous_class_creation
2000         /* Added, JDK1.1 inner classes, modified to use name or
2001            primary instead of primary solely which couldn't work in
2002            all situations.  */
2003 |       something_dot_new identifier OP_TK CP_TK
2004                 {
2005                   tree ctor = build_new_invocation ($2, NULL_TREE);
2006                   $$ = make_qualified_primary ($1, ctor,
2007                                                EXPR_WFL_LINECOL ($1));
2008                 }
2009 |       something_dot_new identifier OP_TK CP_TK class_body
2010 |       something_dot_new identifier OP_TK argument_list CP_TK
2011                 {
2012                   tree ctor = build_new_invocation ($2, $4);
2013                   $$ = make_qualified_primary ($1, ctor,
2014                                                EXPR_WFL_LINECOL ($1));
2015                 }
2016 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2017 |       NEW_TK error SC_TK
2018                 {yyerror ("'(' expected"); DRECOVER(new_1);}
2019 |       NEW_TK class_type error
2020                 {yyerror ("'(' expected"); RECOVER;}
2021 |       NEW_TK class_type OP_TK error
2022                 {yyerror ("')' or term expected"); RECOVER;}
2023 |       NEW_TK class_type OP_TK argument_list error
2024                 {yyerror ("')' expected"); RECOVER;}
2025 |       something_dot_new error
2026                 {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
2027 |       something_dot_new identifier error
2028                 {yyerror ("'(' expected"); RECOVER;}
2029 ;
2030
2031 /* Created after JDK1.1 rules originally added to
2032    class_instance_creation_expression, but modified to use
2033    'class_type' instead of 'TypeName' (type_name) which is mentioned
2034    in the documentation but doesn't exist. */
2035
2036 anonymous_class_creation:
2037         NEW_TK class_type OP_TK argument_list CP_TK
2038                 { create_anonymous_class ($1.location, $2); }
2039         class_body
2040                 {
2041                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2042                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2043
2044                   end_class_declaration (1);
2045
2046                   /* Now we can craft the new expression */
2047                   $$ = build_new_invocation (id, $4);
2048
2049                   /* Note that we can't possibly be here if
2050                      `class_type' is an interface (in which case the
2051                      anonymous class extends Object and implements
2052                      `class_type', hence its constructor can't have
2053                      arguments.) */
2054
2055                   /* Otherwise, the innerclass must feature a
2056                      constructor matching `argument_list'. Anonymous
2057                      classes are a bit special: it's impossible to
2058                      define constructor for them, hence constructors
2059                      must be generated following the hints provided by
2060                      the `new' expression. Whether a super constructor
2061                      of that nature exists or not is to be verified
2062                      later on in verify_constructor_super.
2063
2064                      It's during the expansion of a `new' statement
2065                      refering to an anonymous class that a ctor will
2066                      be generated for the anonymous class, with the
2067                      right arguments. */
2068
2069                 }
2070 |       NEW_TK class_type OP_TK CP_TK
2071                 { create_anonymous_class ($1.location, $2); }
2072         class_body
2073                 {
2074                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2075                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2076
2077                   end_class_declaration (1);
2078
2079                   /* Now we can craft the new expression. The
2080                      statement doesn't need to be remember so that a
2081                      constructor can be generated, since its signature
2082                      is already known. */
2083                   $$ = build_new_invocation (id, NULL_TREE);
2084                 }
2085 ;
2086
2087 something_dot_new:              /* Added, not part of the specs. */
2088         name DOT_TK NEW_TK
2089                 { $$ = $1; }
2090 |       primary DOT_TK NEW_TK
2091                 { $$ = $1; }
2092 ;
2093
2094 argument_list:
2095         expression
2096                 {
2097                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2098                   ctxp->formal_parameter_number = 1;
2099                 }
2100 |       argument_list C_TK expression
2101                 {
2102                   ctxp->formal_parameter_number += 1;
2103                   $$ = tree_cons (NULL_TREE, $3, $1);
2104                 }
2105 |       argument_list C_TK error
2106                 {yyerror ("Missing term"); RECOVER;}
2107 ;
2108
2109 array_creation_expression:
2110         NEW_TK primitive_type dim_exprs
2111                 { $$ = build_newarray_node ($2, $3, 0); }
2112 |       NEW_TK class_or_interface_type dim_exprs
2113                 { $$ = build_newarray_node ($2, $3, 0); }
2114 |       NEW_TK primitive_type dim_exprs dims
2115                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2116 |       NEW_TK class_or_interface_type dim_exprs dims
2117                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2118         /* Added, JDK1.1 anonymous array. Initial documentation rule
2119            modified */
2120 |       NEW_TK class_or_interface_type dims array_initializer
2121                 {
2122                   char *sig;
2123                   int osb = pop_current_osb (ctxp);
2124                   while (osb--)
2125                     obstack_grow (&temporary_obstack, "[]", 2);
2126                   obstack_1grow (&temporary_obstack, '\0');
2127                   sig = obstack_finish (&temporary_obstack);
2128                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2129                               $2, get_identifier (sig), $4);
2130                 }
2131 |       NEW_TK primitive_type dims array_initializer
2132                 {
2133                   int osb = pop_current_osb (ctxp);
2134                   tree type = $2;
2135                   while (osb--)
2136                     type = build_java_array_type (type, -1);
2137                   $$ = build (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2138                               build_pointer_type (type), NULL_TREE, $4);
2139                 }
2140 |       NEW_TK error CSB_TK
2141                 {yyerror ("'[' expected"); DRECOVER ("]");}
2142 |       NEW_TK error OSB_TK
2143                 {yyerror ("']' expected"); RECOVER;}
2144 ;
2145
2146 dim_exprs:
2147         dim_expr
2148                 { $$ = build_tree_list (NULL_TREE, $1); }
2149 |       dim_exprs dim_expr
2150                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2151 ;
2152
2153 dim_expr:
2154         OSB_TK expression CSB_TK
2155                 {
2156                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2157                     {
2158                       $2 = build_wfl_node ($2);
2159                       TREE_TYPE ($2) = NULL_TREE;
2160                     }
2161                   EXPR_WFL_LINECOL ($2) = $1.location;
2162                   $$ = $2;
2163                 }
2164 |       OSB_TK expression error
2165                 {yyerror ("']' expected"); RECOVER;}
2166 |       OSB_TK error
2167                 {
2168                   yyerror ("Missing term");
2169                   yyerror ("']' expected");
2170                   RECOVER;
2171                 }
2172 ;
2173
2174 dims:
2175         OSB_TK CSB_TK
2176                 {
2177                   int allocate = 0;
2178                   /* If not initialized, allocate memory for the osb
2179                      numbers stack */
2180                   if (!ctxp->osb_limit)
2181                     {
2182                       allocate = ctxp->osb_limit = 32;
2183                       ctxp->osb_depth = -1;
2184                     }
2185                   /* If capacity overflown, reallocate a bigger chunk */
2186                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2187                     allocate = ctxp->osb_limit << 1;
2188
2189                   if (allocate)
2190                     {
2191                       allocate *= sizeof (int);
2192                       if (ctxp->osb_number)
2193                         ctxp->osb_number = xrealloc (ctxp->osb_number,
2194                                                      allocate);
2195                       else
2196                         ctxp->osb_number = xmalloc (allocate);
2197                     }
2198                   ctxp->osb_depth++;
2199                   CURRENT_OSB (ctxp) = 1;
2200                 }
2201 |       dims OSB_TK CSB_TK
2202                 { CURRENT_OSB (ctxp)++; }
2203 |       dims OSB_TK error
2204                 { yyerror ("']' expected"); RECOVER;}
2205 ;
2206
2207 field_access:
2208         primary DOT_TK identifier
2209                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2210                 /*  FIXME - REWRITE TO:
2211                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2212 |       SUPER_TK DOT_TK identifier
2213                 {
2214                   tree super_wfl = build_wfl_node (super_identifier_node);
2215                   EXPR_WFL_LINECOL (super_wfl) = $1.location;
2216                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2217                 }
2218 |       SUPER_TK error
2219                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2220 ;
2221
2222 method_invocation:
2223         name OP_TK CP_TK
2224                 { $$ = build_method_invocation ($1, NULL_TREE); }
2225 |       name OP_TK argument_list CP_TK
2226                 { $$ = build_method_invocation ($1, $3); }
2227 |       primary DOT_TK identifier OP_TK CP_TK
2228                 {
2229                   if (TREE_CODE ($1) == THIS_EXPR)
2230                     $$ = build_this_super_qualified_invocation
2231                       (1, $3, NULL_TREE, 0, $2.location);
2232                   else
2233                     {
2234                       tree invok = build_method_invocation ($3, NULL_TREE);
2235                       $$ = make_qualified_primary ($1, invok, $2.location);
2236                     }
2237                 }
2238 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2239                 {
2240                   if (TREE_CODE ($1) == THIS_EXPR)
2241                     $$ = build_this_super_qualified_invocation
2242                       (1, $3, $5, 0, $2.location);
2243                   else
2244                     {
2245                       tree invok = build_method_invocation ($3, $5);
2246                       $$ = make_qualified_primary ($1, invok, $2.location);
2247                     }
2248                 }
2249 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2250                 {
2251                   $$ = build_this_super_qualified_invocation
2252                     (0, $3, NULL_TREE, $1.location, $2.location);
2253                 }
2254 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2255                 {
2256                   $$ = build_this_super_qualified_invocation
2257                     (0, $3, $5, $1.location, $2.location);
2258                 }
2259         /* Screws up thing. I let it here until I'm convinced it can
2260            be removed. FIXME
2261 |       primary DOT_TK error
2262                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2263 |       SUPER_TK DOT_TK error CP_TK
2264                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2265 |       SUPER_TK DOT_TK error DOT_TK
2266                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2267 ;
2268
2269 array_access:
2270         name OSB_TK expression CSB_TK
2271                 { $$ = build_array_ref ($2.location, $1, $3); }
2272 |       primary_no_new_array OSB_TK expression CSB_TK
2273                 { $$ = build_array_ref ($2.location, $1, $3); }
2274 |       name OSB_TK error
2275                 {
2276                   yyerror ("Missing term and ']' expected");
2277                   DRECOVER(array_access);
2278                 }
2279 |       name OSB_TK expression error
2280                 {
2281                   yyerror ("']' expected");
2282                   DRECOVER(array_access);
2283                 }
2284 |       primary_no_new_array OSB_TK error
2285                 {
2286                   yyerror ("Missing term and ']' expected");
2287                   DRECOVER(array_access);
2288                 }
2289 |       primary_no_new_array OSB_TK expression error
2290                 {
2291                   yyerror ("']' expected");
2292                   DRECOVER(array_access);
2293                 }
2294 ;
2295
2296 postfix_expression:
2297         primary
2298 |       name
2299 |       post_increment_expression
2300 |       post_decrement_expression
2301 ;
2302
2303 post_increment_expression:
2304         postfix_expression INCR_TK
2305                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2306 ;
2307
2308 post_decrement_expression:
2309         postfix_expression DECR_TK
2310                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2311 ;
2312
2313 trap_overflow_corner_case:
2314         pre_increment_expression
2315 |       pre_decrement_expression
2316 |       PLUS_TK unary_expression
2317                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2318 |       unary_expression_not_plus_minus
2319 |       PLUS_TK error
2320                 {yyerror ("Missing term"); RECOVER}
2321 ;
2322
2323 unary_expression:
2324         trap_overflow_corner_case
2325                 {
2326                   error_if_numeric_overflow ($1);
2327                   $$ = $1;
2328                 }
2329 |       MINUS_TK trap_overflow_corner_case
2330                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2331 |       MINUS_TK error
2332                 {yyerror ("Missing term"); RECOVER}
2333 ;
2334
2335 pre_increment_expression:
2336         INCR_TK unary_expression
2337                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2338 |       INCR_TK error
2339                 {yyerror ("Missing term"); RECOVER}
2340 ;
2341
2342 pre_decrement_expression:
2343         DECR_TK unary_expression
2344                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2345 |       DECR_TK error
2346                 {yyerror ("Missing term"); RECOVER}
2347 ;
2348
2349 unary_expression_not_plus_minus:
2350         postfix_expression
2351 |       NOT_TK unary_expression
2352                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2353 |       NEG_TK unary_expression
2354                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2355 |       cast_expression
2356 |       NOT_TK error
2357                 {yyerror ("Missing term"); RECOVER}
2358 |       NEG_TK error
2359                 {yyerror ("Missing term"); RECOVER}
2360 ;
2361
2362 cast_expression:                /* Error handling here is potentially weak */
2363         OP_TK primitive_type dims CP_TK unary_expression
2364                 {
2365                   tree type = $2;
2366                   int osb = pop_current_osb (ctxp);
2367                   while (osb--)
2368                     type = build_java_array_type (type, -1);
2369                   $$ = build_cast ($1.location, type, $5);
2370                 }
2371 |       OP_TK primitive_type CP_TK unary_expression
2372                 { $$ = build_cast ($1.location, $2, $4); }
2373 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2374                 { $$ = build_cast ($1.location, $2, $4); }
2375 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2376                 {
2377                   const char *ptr;
2378                   int osb = pop_current_osb (ctxp);
2379                   obstack_grow (&temporary_obstack,
2380                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2381                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2382                   while (osb--)
2383                     obstack_grow (&temporary_obstack, "[]", 2);
2384                   obstack_1grow (&temporary_obstack, '\0');
2385                   ptr = obstack_finish (&temporary_obstack);
2386                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2387                   $$ = build_cast ($1.location, $2, $5);
2388                 }
2389 |       OP_TK primitive_type OSB_TK error
2390                 {yyerror ("']' expected, invalid type expression");}
2391 |       OP_TK error
2392                 {
2393                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2394                   RECOVER;
2395                 }
2396 |       OP_TK primitive_type dims CP_TK error
2397                 {yyerror ("Missing term"); RECOVER;}
2398 |       OP_TK primitive_type CP_TK error
2399                 {yyerror ("Missing term"); RECOVER;}
2400 |       OP_TK name dims CP_TK error
2401                 {yyerror ("Missing term"); RECOVER;}
2402 ;
2403
2404 multiplicative_expression:
2405         unary_expression
2406 |       multiplicative_expression MULT_TK unary_expression
2407                 {
2408                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2409                                     $2.location, $1, $3);
2410                 }
2411 |       multiplicative_expression DIV_TK unary_expression
2412                 {
2413                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2414                                     $1, $3);
2415                 }
2416 |       multiplicative_expression REM_TK unary_expression
2417                 {
2418                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2419                                     $1, $3);
2420                 }
2421 |       multiplicative_expression MULT_TK error
2422                 {yyerror ("Missing term"); RECOVER;}
2423 |       multiplicative_expression DIV_TK error
2424                 {yyerror ("Missing term"); RECOVER;}
2425 |       multiplicative_expression REM_TK error
2426                 {yyerror ("Missing term"); RECOVER;}
2427 ;
2428
2429 additive_expression:
2430         multiplicative_expression
2431 |       additive_expression PLUS_TK multiplicative_expression
2432                 {
2433                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2434                                     $1, $3);
2435                 }
2436 |       additive_expression MINUS_TK multiplicative_expression
2437                 {
2438                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2439                                     $1, $3);
2440                 }
2441 |       additive_expression PLUS_TK error
2442                 {yyerror ("Missing term"); RECOVER;}
2443 |       additive_expression MINUS_TK error
2444                 {yyerror ("Missing term"); RECOVER;}
2445 ;
2446
2447 shift_expression:
2448         additive_expression
2449 |       shift_expression LS_TK additive_expression
2450                 {
2451                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2452                                     $1, $3);
2453                 }
2454 |       shift_expression SRS_TK additive_expression
2455                 {
2456                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2457                                     $1, $3);
2458                 }
2459 |       shift_expression ZRS_TK additive_expression
2460                 {
2461                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2462                                     $1, $3);
2463                 }
2464 |       shift_expression LS_TK error
2465                 {yyerror ("Missing term"); RECOVER;}
2466 |       shift_expression SRS_TK error
2467                 {yyerror ("Missing term"); RECOVER;}
2468 |       shift_expression ZRS_TK error
2469                 {yyerror ("Missing term"); RECOVER;}
2470 ;
2471
2472 relational_expression:
2473         shift_expression
2474 |       relational_expression LT_TK shift_expression
2475                 {
2476                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2477                                     $1, $3);
2478                 }
2479 |       relational_expression GT_TK shift_expression
2480                 {
2481                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2482                                     $1, $3);
2483                 }
2484 |       relational_expression LTE_TK shift_expression
2485                 {
2486                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2487                                     $1, $3);
2488                 }
2489 |       relational_expression GTE_TK shift_expression
2490                 {
2491                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2492                                     $1, $3);
2493                 }
2494 |       relational_expression INSTANCEOF_TK reference_type
2495                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2496 |       relational_expression LT_TK error
2497                 {yyerror ("Missing term"); RECOVER;}
2498 |       relational_expression GT_TK error
2499                 {yyerror ("Missing term"); RECOVER;}
2500 |       relational_expression LTE_TK error
2501                 {yyerror ("Missing term"); RECOVER;}
2502 |       relational_expression GTE_TK error
2503                 {yyerror ("Missing term"); RECOVER;}
2504 |       relational_expression INSTANCEOF_TK error
2505                 {yyerror ("Invalid reference type"); RECOVER;}
2506 ;
2507
2508 equality_expression:
2509         relational_expression
2510 |       equality_expression EQ_TK relational_expression
2511                 {
2512                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2513                                     $1, $3);
2514                 }
2515 |       equality_expression NEQ_TK relational_expression
2516                 {
2517                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2518                                     $1, $3);
2519                 }
2520 |       equality_expression EQ_TK error
2521                 {yyerror ("Missing term"); RECOVER;}
2522 |       equality_expression NEQ_TK error
2523                 {yyerror ("Missing term"); RECOVER;}
2524 ;
2525
2526 and_expression:
2527         equality_expression
2528 |       and_expression AND_TK equality_expression
2529                 {
2530                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2531                                     $1, $3);
2532                 }
2533 |       and_expression AND_TK error
2534                 {yyerror ("Missing term"); RECOVER;}
2535 ;
2536
2537 exclusive_or_expression:
2538         and_expression
2539 |       exclusive_or_expression XOR_TK and_expression
2540                 {
2541                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2542                                     $1, $3);
2543                 }
2544 |       exclusive_or_expression XOR_TK error
2545                 {yyerror ("Missing term"); RECOVER;}
2546 ;
2547
2548 inclusive_or_expression:
2549         exclusive_or_expression
2550 |       inclusive_or_expression OR_TK exclusive_or_expression
2551                 {
2552                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2553                                     $1, $3);
2554                 }
2555 |       inclusive_or_expression OR_TK error
2556                 {yyerror ("Missing term"); RECOVER;}
2557 ;
2558
2559 conditional_and_expression:
2560         inclusive_or_expression
2561 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2562                 {
2563                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2564                                     $1, $3);
2565                 }
2566 |       conditional_and_expression BOOL_AND_TK error
2567                 {yyerror ("Missing term"); RECOVER;}
2568 ;
2569
2570 conditional_or_expression:
2571         conditional_and_expression
2572 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2573                 {
2574                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2575                                     $1, $3);
2576                 }
2577 |       conditional_or_expression BOOL_OR_TK error
2578                 {yyerror ("Missing term"); RECOVER;}
2579 ;
2580
2581 conditional_expression:         /* Error handling here is weak */
2582         conditional_or_expression
2583 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2584                 {
2585                   $$ = build (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2586                   EXPR_WFL_LINECOL ($$) = $2.location;
2587                 }
2588 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2589                 {
2590                   YYERROR_NOW;
2591                   yyerror ("Missing term");
2592                   DRECOVER (1);
2593                 }
2594 |       conditional_or_expression REL_QM_TK error
2595                 {yyerror ("Missing term"); DRECOVER (2);}
2596 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2597                 {yyerror ("Missing term"); DRECOVER (3);}
2598 ;
2599
2600 assignment_expression:
2601         conditional_expression
2602 |       assignment
2603 ;
2604
2605 assignment:
2606         left_hand_side assignment_operator assignment_expression
2607                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2608 |       left_hand_side assignment_operator error
2609                 {
2610                   YYNOT_TWICE yyerror ("Missing term");
2611                   DRECOVER (assign);
2612                 }
2613 ;
2614
2615 left_hand_side:
2616         name
2617 |       field_access
2618 |       array_access
2619 ;
2620
2621 assignment_operator:
2622         ASSIGN_ANY_TK
2623 |       ASSIGN_TK
2624 ;
2625
2626 expression:
2627         assignment_expression
2628 ;
2629
2630 constant_expression:
2631         expression
2632 ;
2633
2634 %%
2635
2636 /* Helper function to retrieve an OSB count. Should be used when the
2637    `dims:' rule is being used.  */
2638
2639 static int
2640 pop_current_osb (struct parser_ctxt *ctxp)
2641 {
2642   int to_return;
2643
2644   if (ctxp->osb_depth < 0)
2645     abort ();
2646
2647   to_return = CURRENT_OSB (ctxp);
2648   ctxp->osb_depth--;
2649
2650   return to_return;
2651 }
2652
2653 \f
2654
2655 /* This section of the code deal with save/restoring parser contexts.
2656    Add mode documentation here. FIXME */
2657
2658 /* Helper function. Create a new parser context. With
2659    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2660    context is copied, otherwise, the new context is zeroed. The newly
2661    created context becomes the current one.  */
2662
2663 static void
2664 create_new_parser_context (int copy_from_previous)
2665 {
2666   struct parser_ctxt *new;
2667
2668   new = ggc_alloc (sizeof (struct parser_ctxt));
2669   if (copy_from_previous)
2670     {
2671       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2672       /* This flag, indicating the context saves global values,
2673          should only be set by java_parser_context_save_global.  */
2674       new->saved_data_ctx = 0;
2675     }
2676   else
2677     memset (new, 0, sizeof (struct parser_ctxt));
2678
2679   new->next = ctxp;
2680   ctxp = new;
2681 }
2682
2683 /* Create a new parser context and make it the current one. */
2684
2685 void
2686 java_push_parser_context (void)
2687 {
2688   create_new_parser_context (0);
2689 }
2690
2691 void
2692 java_pop_parser_context (int generate)
2693 {
2694   tree current;
2695   struct parser_ctxt *toFree, *next;
2696
2697   if (!ctxp)
2698     return;
2699
2700   toFree = ctxp;
2701   next = ctxp->next;
2702   if (next)
2703     {
2704       input_line = ctxp->lineno;
2705       current_class = ctxp->class_type;
2706     }
2707
2708   /* If the old and new lexers differ, then free the old one.  */
2709   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2710     java_destroy_lexer (ctxp->lexer);
2711
2712   /* Set the single import class file flag to 0 for the current list
2713      of imported things */
2714   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2715     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2716
2717   /* And restore those of the previous context */
2718   if ((ctxp = next))            /* Assignment is really meant here */
2719     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2720       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2721
2722   /* If we pushed a context to parse a class intended to be generated,
2723      we keep it so we can remember the class. What we could actually
2724      do is to just update a list of class names.  */
2725   if (generate)
2726     {
2727       toFree->next = ctxp_for_generation;
2728       ctxp_for_generation = toFree;
2729     }
2730 }
2731
2732 /* Create a parser context for the use of saving some global
2733    variables.  */
2734
2735 void
2736 java_parser_context_save_global (void)
2737 {
2738   if (!ctxp)
2739     {
2740       java_push_parser_context ();
2741       ctxp->saved_data_ctx = 1;
2742     }
2743
2744   /* If this context already stores data, create a new one suitable
2745      for data storage. */
2746   else if (ctxp->saved_data)
2747     {
2748       create_new_parser_context (1);
2749       ctxp->saved_data_ctx = 1;
2750     }
2751
2752   ctxp->lineno = input_line;
2753   ctxp->class_type = current_class;
2754   ctxp->filename = input_filename;
2755   ctxp->function_decl = current_function_decl;
2756   ctxp->saved_data = 1;
2757 }
2758
2759 /* Restore some global variables from the previous context. Make the
2760    previous context the current one.  */
2761
2762 void
2763 java_parser_context_restore_global (void)
2764 {
2765   input_line = ctxp->lineno;
2766   current_class = ctxp->class_type;
2767   input_filename = ctxp->filename;
2768   if (wfl_operator)
2769     {
2770       tree s;
2771       BUILD_FILENAME_IDENTIFIER_NODE (s, input_filename);
2772       EXPR_WFL_FILENAME_NODE (wfl_operator) = s;
2773     }
2774   current_function_decl = ctxp->function_decl;
2775   ctxp->saved_data = 0;
2776   if (ctxp->saved_data_ctx)
2777     java_pop_parser_context (0);
2778 }
2779
2780 /* Suspend vital data for the current class/function being parsed so
2781    that an other class can be parsed. Used to let local/anonymous
2782    classes be parsed.  */
2783
2784 static void
2785 java_parser_context_suspend (void)
2786 {
2787   /* This makes debugging through java_debug_context easier */
2788   static const char *const name = "<inner buffer context>";
2789
2790   /* Duplicate the previous context, use it to save the globals we're
2791      interested in */
2792   create_new_parser_context (1);
2793   ctxp->function_decl = current_function_decl;
2794   ctxp->class_type = current_class;
2795
2796   /* Then create a new context which inherits all data from the
2797      previous one. This will be the new current context  */
2798   create_new_parser_context (1);
2799
2800   /* Help debugging */
2801   ctxp->next->filename = name;
2802 }
2803
2804 /* Resume vital data for the current class/function being parsed so
2805    that an other class can be parsed. Used to let local/anonymous
2806    classes be parsed.  The trick is the data storing file position
2807    informations must be restored to their current value, so parsing
2808    can resume as if no context was ever saved. */
2809
2810 static void
2811 java_parser_context_resume (void)
2812 {
2813   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2814   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2815   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2816
2817   /* We need to inherit the list of classes to complete/generate */
2818   restored->classd_list = old->classd_list;
2819   restored->class_list = old->class_list;
2820
2821   /* Restore the current class and function from the saver */
2822   current_class = saver->class_type;
2823   current_function_decl = saver->function_decl;
2824
2825   /* Retrieve the restored context */
2826   ctxp = restored;
2827
2828   /* Re-installed the data for the parsing to carry on */
2829   memcpy (&ctxp->marker_begining, &old->marker_begining,
2830           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2831 }
2832
2833 /* Add a new anchor node to which all statement(s) initializing static
2834    and non static initialized upon declaration field(s) will be
2835    linked.  */
2836
2837 static void
2838 java_parser_context_push_initialized_field (void)
2839 {
2840   tree node;
2841
2842   node = build_tree_list (NULL_TREE, NULL_TREE);
2843   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2844   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2845
2846   node = build_tree_list (NULL_TREE, NULL_TREE);
2847   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2848   CPC_INITIALIZER_LIST (ctxp) = node;
2849
2850   node = build_tree_list (NULL_TREE, NULL_TREE);
2851   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2852   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2853 }
2854
2855 /* Pop the lists of initialized field. If this lists aren't empty,
2856    remember them so we can use it to create and populate the finit$
2857    or <clinit> functions. */
2858
2859 static void
2860 java_parser_context_pop_initialized_field (void)
2861 {
2862   tree stmts;
2863   tree class_type = TREE_TYPE (GET_CPC ());
2864
2865   if (CPC_INITIALIZER_LIST (ctxp))
2866     {
2867       stmts = CPC_INITIALIZER_STMT (ctxp);
2868       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2869       if (stmts && !java_error_count)
2870         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2871     }
2872
2873   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2874     {
2875       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2876       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2877         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2878       /* Keep initialization in order to enforce 8.5 */
2879       if (stmts && !java_error_count)
2880         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2881     }
2882
2883   /* JDK 1.1 instance initializers */
2884   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2885     {
2886       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2887       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2888         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2889       if (stmts && !java_error_count)
2890         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2891     }
2892 }
2893
2894 static tree
2895 reorder_static_initialized (tree list)
2896 {
2897   /* We have to keep things in order. The alias initializer have to
2898      come first, then the initialized regular field, in reverse to
2899      keep them in lexical order. */
2900   tree marker, previous = NULL_TREE;
2901   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2902     if (TREE_CODE (marker) == TREE_LIST
2903         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2904       break;
2905
2906   /* No static initialized, the list is fine as is */
2907   if (!previous)
2908     list = TREE_CHAIN (marker);
2909
2910   /* No marker? reverse the whole list */
2911   else if (!marker)
2912     list = nreverse (list);
2913
2914   /* Otherwise, reverse what's after the marker and the new reordered
2915      sublist will replace the marker. */
2916   else
2917     {
2918       TREE_CHAIN (previous) = NULL_TREE;
2919       list = nreverse (list);
2920       list = chainon (TREE_CHAIN (marker), list);
2921     }
2922   return list;
2923 }
2924
2925 /* Helper functions to dump the parser context stack.  */
2926
2927 #define TAB_CONTEXT(C) \
2928   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2929
2930 static void
2931 java_debug_context_do (int tab)
2932 {
2933   struct parser_ctxt *copy = ctxp;
2934   while (copy)
2935     {
2936       TAB_CONTEXT (tab);
2937       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2938       TAB_CONTEXT (tab);
2939       fprintf (stderr, "filename: %s\n", copy->filename);
2940       TAB_CONTEXT (tab);
2941       fprintf (stderr, "lineno: %d\n", copy->lineno);
2942       TAB_CONTEXT (tab);
2943       fprintf (stderr, "package: %s\n",
2944                (copy->package ?
2945                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2946       TAB_CONTEXT (tab);
2947       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2948       TAB_CONTEXT (tab);
2949       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2950       copy = copy->next;
2951       tab += 2;
2952     }
2953 }
2954
2955 /* Dump the stacked up parser contexts. Intended to be called from a
2956    debugger.  */
2957
2958 void
2959 java_debug_context (void)
2960 {
2961   java_debug_context_do (0);
2962 }
2963
2964 \f
2965
2966 /* Flag for the error report routine to issue the error the first time
2967    it's called (overriding the default behavior which is to drop the
2968    first invocation and honor the second one, taking advantage of a
2969    richer context.  */
2970 static int force_error = 0;
2971
2972 /* Reporting an constructor invocation error.  */
2973 static void
2974 parse_ctor_invocation_error (void)
2975 {
2976   if (DECL_CONSTRUCTOR_P (current_function_decl))
2977     yyerror ("Constructor invocation must be first thing in a constructor");
2978   else
2979     yyerror ("Only constructors can invoke constructors");
2980 }
2981
2982 /* Reporting JDK1.1 features not implemented.  */
2983
2984 static tree
2985 parse_jdk1_1_error (const char *msg)
2986 {
2987   sorry (": `%s' JDK1.1(TM) feature", msg);
2988   java_error_count++;
2989   return empty_stmt_node;
2990 }
2991
2992 static int do_warning = 0;
2993
2994 void
2995 yyerror (const char *msg)
2996 {
2997   static java_lc elc;
2998   static int  prev_lineno;
2999   static const char *prev_msg;
3000
3001   int save_lineno;
3002   char *remainder, *code_from_source;
3003
3004   if (!force_error && prev_lineno == input_line)
3005     return;
3006
3007   /* Save current error location but report latter, when the context is
3008      richer.  */
3009   if (ctxp->java_error_flag == 0)
3010     {
3011       ctxp->java_error_flag = 1;
3012       elc = ctxp->elc;
3013       /* Do something to use the previous line if we're reaching the
3014          end of the file... */
3015 #ifdef VERBOSE_SKELETON
3016       printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
3017 #endif
3018       return;
3019     }
3020
3021   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3022   if (!force_error && msg == prev_msg && prev_lineno == elc.line)
3023     return;
3024
3025   ctxp->java_error_flag = 0;
3026   if (do_warning)
3027     java_warning_count++;
3028   else
3029     java_error_count++;
3030
3031   if (elc.col == 0 && msg && msg[1] == ';')
3032     {
3033       elc.col  = ctxp->p_line->char_col-1;
3034       elc.line = ctxp->p_line->lineno;
3035     }
3036
3037   save_lineno = input_line;
3038   prev_lineno = input_line = elc.line;
3039   prev_msg = msg;
3040
3041   code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
3042   obstack_grow0 (&temporary_obstack,
3043                  code_from_source, strlen (code_from_source));
3044   remainder = obstack_finish (&temporary_obstack);
3045   if (do_warning)
3046     warning ("%s.\n%s", msg, remainder);
3047   else
3048     error ("%s.\n%s", msg, remainder);
3049
3050   /* This allow us to cheaply avoid an extra 'Invalid expression
3051      statement' error report when errors have been already reported on
3052      the same line. This occurs when we report an error but don't have
3053      a synchronization point other than ';', which
3054      expression_statement is the only one to take care of.  */
3055   ctxp->prevent_ese = input_line = save_lineno;
3056 }
3057
3058 static void
3059 issue_warning_error_from_context (tree cl, const char *msg, va_list ap)
3060 {
3061   const char *saved, *saved_input_filename;
3062   char buffer [4096];
3063   vsprintf (buffer, msg, ap);
3064   force_error = 1;
3065
3066   ctxp->elc.line = EXPR_WFL_LINENO (cl);
3067   ctxp->elc.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 :
3068                     (EXPR_WFL_COLNO (cl) == 0xffe ? -2 : EXPR_WFL_COLNO (cl)));
3069
3070   /* We have a CL, that's a good reason for using it if it contains data */
3071   saved = ctxp->filename;
3072   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3073     ctxp->filename = EXPR_WFL_FILENAME (cl);
3074   saved_input_filename = input_filename;
3075   input_filename = ctxp->filename;
3076   java_error (NULL);
3077   java_error (buffer);
3078   ctxp->filename = saved;
3079   input_filename = saved_input_filename;
3080   force_error = 0;
3081 }
3082
3083 /* Issue an error message at a current source line CL */
3084
3085 void
3086 parse_error_context (tree cl, const char *msg, ...)
3087 {
3088   va_list ap;
3089   va_start (ap, msg);
3090   issue_warning_error_from_context (cl, msg, ap);
3091   va_end (ap);
3092 }
3093
3094 /* Issue a warning at a current source line CL */
3095
3096 static void
3097 parse_warning_context (tree cl, const char *msg, ...)
3098 {
3099   va_list ap;
3100   va_start (ap, msg);
3101
3102   force_error = do_warning = 1;
3103   issue_warning_error_from_context (cl, msg, ap);
3104   do_warning = force_error = 0;
3105   va_end (ap);
3106 }
3107
3108 static tree
3109 find_expr_with_wfl (tree node)
3110 {
3111   while (node)
3112     {
3113       char code;
3114       tree to_return;
3115
3116       switch (TREE_CODE (node))
3117         {
3118         case BLOCK:
3119           node = BLOCK_EXPR_BODY (node);
3120           continue;
3121
3122         case COMPOUND_EXPR:
3123           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3124           if (to_return)
3125             return to_return;
3126           node = TREE_OPERAND (node, 1);
3127           continue;
3128
3129         case LOOP_EXPR:
3130           node = TREE_OPERAND (node, 0);
3131           continue;
3132
3133         case LABELED_BLOCK_EXPR:
3134           node = TREE_OPERAND (node, 1);
3135           continue;
3136
3137         default:
3138           code = TREE_CODE_CLASS (TREE_CODE (node));
3139           if (((code == '1') || (code == '2') || (code == 'e'))
3140               && EXPR_WFL_LINECOL (node))
3141             return node;
3142           return NULL_TREE;
3143         }
3144     }
3145   return NULL_TREE;
3146 }
3147
3148 /* Issue a missing return statement error. Uses METHOD to figure the
3149    last line of the method the error occurs in.  */
3150
3151 static void
3152 missing_return_error (tree method)
3153 {
3154   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3155   parse_error_context (wfl_operator, "Missing return statement");
3156 }
3157
3158 /* Issue an unreachable statement error. From NODE, find the next
3159    statement to report appropriately.  */
3160 static void
3161 unreachable_stmt_error (tree node)
3162 {
3163   /* Browse node to find the next expression node that has a WFL. Use
3164      the location to report the error */
3165   if (TREE_CODE (node) == COMPOUND_EXPR)
3166     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3167   else
3168     node = find_expr_with_wfl (node);
3169
3170   if (node)
3171     {
3172       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3173       parse_error_context (wfl_operator, "Unreachable statement");
3174     }
3175   else
3176     abort ();
3177 }
3178
3179 static int
3180 not_accessible_field_error (tree wfl, tree decl)
3181 {
3182   parse_error_context
3183     (wfl, "Can't access %s field `%s.%s' from `%s'",
3184      java_accstring_lookup (get_access_flags_from_decl (decl)),
3185      GET_TYPE_NAME (DECL_CONTEXT (decl)),
3186      IDENTIFIER_POINTER (DECL_NAME (decl)),
3187      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3188   return 1;
3189 }
3190
3191 int
3192 java_report_errors (void)
3193 {
3194   if (java_error_count)
3195     fprintf (stderr, "%d error%s",
3196              java_error_count, (java_error_count == 1 ? "" : "s"));
3197   if (java_warning_count)
3198     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3199              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3200   if (java_error_count || java_warning_count)
3201     putc ('\n', stderr);
3202   return java_error_count;
3203 }
3204
3205 static char *
3206 java_accstring_lookup (int flags)
3207 {
3208   static char buffer [80];
3209 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3210
3211   /* Access modifier looked-up first for easier report on forbidden
3212      access. */
3213   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3214   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3215   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3216   if (flags & ACC_STATIC) COPY_RETURN ("static");
3217   if (flags & ACC_FINAL) COPY_RETURN ("final");
3218   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3219   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3220   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3221   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3222   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3223   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3224
3225   buffer [0] = '\0';
3226   return buffer;
3227 #undef COPY_RETURN
3228 }
3229
3230 /* Issuing error messages upon redefinition of classes, interfaces or
3231    variables. */
3232
3233 static void
3234 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3235 {
3236   parse_error_context (cl, "%s `%s' already defined in %s:%d",
3237                        context, IDENTIFIER_POINTER (id),
3238                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3239   /* Here we should point out where its redefined. It's a unicode. FIXME */
3240 }
3241
3242 static void
3243 variable_redefinition_error (tree context, tree name, tree type, int line)
3244 {
3245   const char *type_name;
3246
3247   /* Figure a proper name for type. We might haven't resolved it */
3248   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3249     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3250   else
3251     type_name = lang_printable_name (type, 0);
3252
3253   parse_error_context (context,
3254                        "Variable `%s' is already defined in this method and was declared `%s %s' at line %d",
3255                        IDENTIFIER_POINTER (name),
3256                        type_name, IDENTIFIER_POINTER (name), line);
3257 }
3258
3259 /* If ANAME is terminated with `[]', it indicates an array. This
3260    function returns the number of `[]' found and if this number is
3261    greater than zero, it extracts the array type name and places it in
3262    the node pointed to by TRIMMED unless TRIMMED is null.  */
3263
3264 static int
3265 build_type_name_from_array_name (tree aname, tree *trimmed)
3266 {
3267   const char *name = IDENTIFIER_POINTER (aname);
3268   int len = IDENTIFIER_LENGTH (aname);
3269   int array_dims;
3270
3271   STRING_STRIP_BRACKETS (name, len, array_dims);
3272
3273   if (array_dims && trimmed)
3274     *trimmed = get_identifier_with_length (name, len);
3275
3276   return array_dims;
3277 }
3278
3279 static tree
3280 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3281 {
3282   int more_dims = 0;
3283
3284   /* Eventually get more dims */
3285   more_dims = build_type_name_from_array_name (name, &name);
3286
3287   /* If we have, then craft a new type for this variable */
3288   if (more_dims)
3289     {
3290       tree save = type;
3291
3292       /* If we have a pointer, use its type */
3293       if (TREE_CODE (type) == POINTER_TYPE)
3294         type = TREE_TYPE (type);
3295
3296       /* Building the first dimension of a primitive type uses this
3297          function */
3298       if (JPRIMITIVE_TYPE_P (type))
3299         {
3300           type = build_java_array_type (type, -1);
3301           more_dims--;
3302         }
3303       /* Otherwise, if we have a WFL for this type, use it (the type
3304          is already an array on an unresolved type, and we just keep
3305          on adding dimensions) */
3306       else if (type_wfl)
3307         {
3308           type = type_wfl;
3309           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3310                                                         NULL);
3311         }
3312
3313       /* Add all the dimensions */
3314       while (more_dims--)
3315         type = build_unresolved_array_type (type);
3316
3317       /* The type may have been incomplete in the first place */
3318       if (type_wfl)
3319         type = obtain_incomplete_type (type);
3320     }
3321
3322   if (ret_name)
3323     *ret_name = name;
3324   return type;
3325 }
3326
3327 /* Build something that the type identifier resolver will identify as
3328    being an array to an unresolved type. TYPE_WFL is a WFL on a
3329    identifier. */
3330
3331 static tree
3332 build_unresolved_array_type (tree type_or_wfl)
3333 {
3334   const char *ptr;
3335   tree wfl;
3336
3337   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3338      just create a array type */
3339   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3340     return build_java_array_type (type_or_wfl, -1);
3341
3342   obstack_grow (&temporary_obstack,
3343                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3344                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3345   obstack_grow0 (&temporary_obstack, "[]", 2);
3346   ptr = obstack_finish (&temporary_obstack);
3347   wfl = build_expr_wfl (get_identifier (ptr),
3348                         EXPR_WFL_FILENAME (type_or_wfl),
3349                         EXPR_WFL_LINENO (type_or_wfl),
3350                         EXPR_WFL_COLNO (type_or_wfl));
3351   /* Re-install the existing qualifications so that the type can be
3352      resolved properly. */
3353   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3354   return wfl;
3355 }
3356
3357 static void
3358 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3359 {
3360   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3361     parse_error_context (wfl, "Interface `%s' repeated",
3362                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3363 }
3364
3365 /* Bulk of common class/interface checks. Return 1 if an error was
3366    encountered. TAG is 0 for a class, 1 for an interface.  */
3367
3368 static int
3369 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3370                                 tree qualified_name, tree decl, tree cl)
3371 {
3372   tree node;
3373   int sca = 0;                  /* Static class allowed */
3374   int icaf = 0;                 /* Inner class allowed flags */
3375   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3376
3377   if (!quiet_flag)
3378     fprintf (stderr, " %s%s %s",
3379              (CPC_INNER_P () ? "inner" : ""),
3380              (is_interface ? "interface" : "class"),
3381              IDENTIFIER_POINTER (qualified_name));
3382
3383   /* Scope of an interface/class type name:
3384        - Can't be imported by a single type import
3385        - Can't already exists in the package */
3386   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3387       && (node = find_name_in_single_imports (raw_name))
3388       && !CPC_INNER_P ())
3389     {
3390       parse_error_context
3391         (cl, "%s name `%s' clashes with imported type `%s'",
3392          (is_interface ? "Interface" : "Class"),
3393          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3394       return 1;
3395     }
3396   if (decl && CLASS_COMPLETE_P (decl))
3397     {
3398       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3399                                    qualified_name, decl, cl);
3400       return 1;
3401     }
3402
3403   if (check_inner_class_redefinition (raw_name, cl))
3404     return 1;
3405
3406   /* If public, file name should match class/interface name, except
3407      when dealing with an inner class */
3408   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3409     {
3410       const char *f;
3411
3412       for (f = &input_filename [strlen (input_filename)];
3413            f != input_filename && ! IS_DIR_SEPARATOR (f[0]);
3414            f--)
3415         ;
3416       if (IS_DIR_SEPARATOR (f[0]))
3417         f++;
3418       if (strncmp (IDENTIFIER_POINTER (raw_name),
3419                    f , IDENTIFIER_LENGTH (raw_name)) ||
3420           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3421         parse_error_context
3422           (cl, "Public %s `%s' must be defined in a file called `%s.java'",
3423                              (is_interface ? "interface" : "class"),
3424                              IDENTIFIER_POINTER (qualified_name),
3425                              IDENTIFIER_POINTER (raw_name));
3426     }
3427
3428   /* Static classes can be declared only in top level classes. Note:
3429      once static, a inner class is a top level class. */
3430   if (flags & ACC_STATIC)
3431     {
3432       /* Catch the specific error of declaring an class inner class
3433          with no toplevel enclosing class. Prevent check_modifiers from
3434          complaining a second time */
3435       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3436         {
3437           parse_error_context (cl, "Inner class `%s' can't be static. Static classes can only occur in interfaces and top-level classes",
3438                                IDENTIFIER_POINTER (qualified_name));
3439           sca = ACC_STATIC;
3440         }
3441       /* Else, in the context of a top-level class declaration, let
3442          `check_modifiers' do its job, otherwise, give it a go */
3443       else
3444         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3445     }
3446
3447   /* Inner classes can be declared private or protected
3448      within their enclosing classes. */
3449   if (CPC_INNER_P ())
3450     {
3451       /* A class which is local to a block can't be public, private,
3452          protected or static. But it is created final, so allow this
3453          one. */
3454       if (current_function_decl)
3455         icaf = sca = uaaf = ACC_FINAL;
3456       else
3457         {
3458           check_modifiers_consistency (flags);
3459           icaf = ACC_PROTECTED;
3460           if (! CLASS_INTERFACE (GET_CPC ()))
3461             icaf |= ACC_PRIVATE;
3462         }
3463     }
3464
3465   if (is_interface)
3466     {
3467       if (CPC_INNER_P ())
3468         uaaf = INTERFACE_INNER_MODIFIERS;
3469       else
3470         uaaf = INTERFACE_MODIFIERS;
3471
3472       check_modifiers ("Illegal modifier `%s' for interface declaration",
3473                        flags, uaaf);
3474     }
3475   else
3476     check_modifiers ((current_function_decl ?
3477                       "Illegal modifier `%s' for local class declaration" :
3478                       "Illegal modifier `%s' for class declaration"),
3479                      flags, uaaf|sca|icaf);
3480   return 0;
3481 }
3482
3483 /* Construct a nested class name.  If the final component starts with
3484    a digit, return true.  Otherwise return false.  */
3485 static int
3486 make_nested_class_name (tree cpc_list)
3487 {
3488   tree name;
3489
3490   if (!cpc_list)
3491     return 0;
3492
3493   make_nested_class_name (TREE_CHAIN (cpc_list));
3494
3495   /* Pick the qualified name when dealing with the first upmost
3496      enclosing class */
3497   name = (TREE_CHAIN (cpc_list)
3498           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3499   obstack_grow (&temporary_obstack,
3500                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3501   obstack_1grow (&temporary_obstack, '$');
3502
3503   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3504 }
3505
3506 /* Can't redefine a class already defined in an earlier scope. */
3507
3508 static int
3509 check_inner_class_redefinition (tree raw_name, tree cl)
3510 {
3511   tree scope_list;
3512
3513   for (scope_list = GET_CPC_LIST (); scope_list;
3514        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3515     if (raw_name == GET_CPC_UN_NODE (scope_list))
3516       {
3517         parse_error_context
3518           (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",
3519            IDENTIFIER_POINTER (raw_name));
3520         return 1;
3521       }
3522   return 0;
3523 }
3524
3525 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3526    we remember ENCLOSING and SUPER.  */
3527
3528 static tree
3529 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3530                      tree *super, tree class_type)
3531 {
3532   tree local_enclosing = *enclosing;
3533   tree local_super = NULL_TREE;
3534
3535   while (local_enclosing)
3536     {
3537       tree intermediate, decl;
3538
3539       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3540         local_enclosing;
3541
3542       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3543         return decl;
3544
3545       intermediate = local_enclosing;
3546       /* Explore enclosing contexts. */
3547       while (INNER_CLASS_DECL_P (intermediate))
3548         {
3549           intermediate = DECL_CONTEXT (intermediate);
3550           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3551             return decl;
3552         }
3553
3554       /* Now go to the upper classes, bail out if necessary.  We will
3555          analyze the returned SUPER and act accordingly (see
3556          do_resolve_class).  */
3557       if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3558           || TREE_TYPE (local_enclosing) == void_type_node)
3559         {
3560           parse_error_context (cl, "Qualifier must be a reference");
3561           local_enclosing = NULL_TREE;
3562           break;
3563         }
3564       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3565       if (!local_super || local_super == object_type_node)
3566         break;
3567
3568       if (TREE_CODE (local_super) == POINTER_TYPE)
3569         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3570       else
3571         local_super = TYPE_NAME (local_super);
3572
3573       /* We may not have checked for circular inheritance yet, so do so
3574          here to prevent an infinite loop. */
3575       if (htab_find (circularity_hash, local_super) != NULL)
3576         {
3577           if (!cl)
3578             cl = lookup_cl (local_enclosing);
3579
3580           parse_error_context
3581             (cl, "Cyclic inheritance involving %s",
3582              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3583           local_enclosing = NULL_TREE;
3584         }
3585       else
3586         local_enclosing = local_super;
3587     }
3588
3589   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3590   *super = local_super;
3591   *enclosing = local_enclosing;
3592
3593   return NULL_TREE;
3594 }
3595
3596 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3597    qualified. */
3598
3599 static tree
3600 find_as_inner_class (tree enclosing, tree name, tree cl)
3601 {
3602   tree qual, to_return;
3603   if (!enclosing)
3604     return NULL_TREE;
3605
3606   name = TYPE_NAME (name);
3607
3608   /* First search: within the scope of `enclosing', search for name */
3609   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3610     qual = EXPR_WFL_QUALIFICATION (cl);
3611   else if (cl)
3612     qual = build_tree_list (cl, NULL_TREE);
3613   else
3614     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3615
3616   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3617     return to_return;
3618
3619   /* We're dealing with a qualified name. Try to resolve thing until
3620      we get something that is an enclosing class. */
3621   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3622     {
3623       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3624
3625       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3626            qual = TREE_CHAIN (qual))
3627         {
3628           acc = merge_qualified_name (acc,
3629                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3630           BUILD_PTR_FROM_NAME (ptr, acc);
3631           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3632         }
3633
3634       /* A NULL qual and a decl means that the search ended
3635          successfully?!? We have to do something then. FIXME */
3636
3637       if (decl)
3638         enclosing = decl;
3639       else
3640         qual = EXPR_WFL_QUALIFICATION (cl);
3641     }
3642   /* Otherwise, create a qual for the other part of the resolution. */
3643   else
3644     qual = build_tree_list (build_expr_wfl (name, NULL, 0, 0), NULL_TREE);
3645
3646   return find_as_inner_class_do (qual, enclosing);
3647 }
3648
3649 /* We go inside the list of sub classes and try to find a way
3650    through. */
3651
3652 static tree
3653 find_as_inner_class_do (tree qual, tree enclosing)
3654 {
3655   if (!qual)
3656     return NULL_TREE;
3657
3658   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3659     {
3660       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3661       tree next_enclosing = NULL_TREE;
3662       tree inner_list;
3663
3664       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3665            inner_list; inner_list = TREE_CHAIN (inner_list))
3666         {
3667           if (TREE_VALUE (inner_list) == name_to_match)
3668             {
3669               next_enclosing = TREE_PURPOSE (inner_list);
3670               break;
3671             }
3672         }
3673       enclosing = next_enclosing;
3674     }
3675
3676   return (!qual && enclosing ? enclosing : NULL_TREE);
3677 }
3678
3679 /* Reach all inner classes and tie their unqualified name to a
3680    DECL. */
3681
3682 static void
3683 set_nested_class_simple_name_value (tree outer, int set)
3684 {
3685   tree l;
3686
3687   for (l = DECL_INNER_CLASS_LIST (outer); l; l = TREE_CHAIN (l))
3688     IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (l)) = (set ?
3689                                                 TREE_PURPOSE (l) : NULL_TREE);
3690 }
3691
3692 static void
3693 link_nested_class_to_enclosing (void)
3694 {
3695   if (GET_ENCLOSING_CPC ())
3696     {
3697       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3698       DECL_INNER_CLASS_LIST (enclosing) =
3699         tree_cons (GET_CPC (), GET_CPC_UN (),
3700                    DECL_INNER_CLASS_LIST (enclosing));
3701     }
3702 }
3703
3704 static tree
3705 maybe_make_nested_class_name (tree name)
3706 {
3707   tree id = NULL_TREE;
3708
3709   if (CPC_INNER_P ())
3710     {
3711       /* If we're in a function, we must append a number to create the
3712          nested class name.  However, we don't do this if the class we
3713          are constructing is anonymous, because in that case we'll
3714          already have a number as the class name.  */
3715       if (! make_nested_class_name (GET_CPC_LIST ())
3716           && current_function_decl != NULL_TREE
3717           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3718         {
3719           char buf[10];
3720           sprintf (buf, "%d", anonymous_class_counter);
3721           ++anonymous_class_counter;
3722           obstack_grow (&temporary_obstack, buf, strlen (buf));
3723           obstack_1grow (&temporary_obstack, '$');
3724         }
3725       obstack_grow0 (&temporary_obstack,
3726                      IDENTIFIER_POINTER (name),
3727                      IDENTIFIER_LENGTH (name));
3728       id = get_identifier (obstack_finish (&temporary_obstack));
3729       if (ctxp->package)
3730         QUALIFIED_P (id) = 1;
3731     }
3732   return id;
3733 }
3734
3735 /* If DECL is NULL, create and push a new DECL, record the current
3736    line CL and do other maintenance things.  */
3737
3738 static tree
3739 maybe_create_class_interface_decl (tree decl, tree raw_name,
3740                                    tree qualified_name, tree cl)
3741 {
3742   if (!decl)
3743     decl = push_class (make_class (), qualified_name);
3744
3745   /* Take care of the file and line business */
3746   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3747   /* If we're emitting xrefs, store the line/col number information */
3748   if (flag_emit_xref)
3749     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (cl);
3750   else
3751     DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3752   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3753   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3754   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3755     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3756
3757   PUSH_CPC (decl, raw_name);
3758   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3759
3760   /* Link the declaration to the already seen ones */
3761   TREE_CHAIN (decl) = ctxp->class_list;
3762   ctxp->class_list = decl;
3763
3764   /* Create a new nodes in the global lists */
3765   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3766   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3767
3768   /* Install a new dependency list element */
3769   create_jdep_list (ctxp);
3770
3771   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3772                           IDENTIFIER_POINTER (qualified_name)));
3773   return decl;
3774 }
3775
3776 static void
3777 add_superinterfaces (tree decl, tree interface_list)
3778 {
3779   tree node;
3780   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3781      takes care of ensuring that:
3782        - This is an accessible interface type,
3783        - Circularity detection.
3784    parser_add_interface is then called. If present but not defined,
3785    the check operation is delayed until the super interface gets
3786    defined.  */
3787   for (node = interface_list; node; node = TREE_CHAIN (node))
3788     {
3789       tree current = TREE_PURPOSE (node);
3790       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3791       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3792         {
3793           if (!parser_check_super_interface (idecl, decl, current))
3794             parser_add_interface (decl, idecl, current);
3795         }
3796       else
3797         register_incomplete_type (JDEP_INTERFACE,
3798                                   current, decl, NULL_TREE);
3799     }
3800 }
3801
3802 /* Create an interface in pass1 and return its decl. Return the
3803    interface's decl in pass 2.  */
3804
3805 static tree
3806 create_interface (int flags, tree id, tree super)
3807 {
3808   tree raw_name = EXPR_WFL_NODE (id);
3809   tree q_name = parser_qualified_classname (raw_name);
3810   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3811
3812   /* Certain syntax errors are making SUPER be like ID. Avoid this
3813      case. */
3814   if (ctxp->class_err && id == super)
3815     super = NULL;
3816
3817   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3818
3819   /* Basic checks: scope, redefinition, modifiers */
3820   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3821     {
3822       PUSH_ERROR ();
3823       return NULL_TREE;
3824     }
3825
3826   /* Suspend the current parsing context if we're parsing an inner
3827      interface */
3828   if (CPC_INNER_P ())
3829     {
3830       java_parser_context_suspend ();
3831       /* Interface members are public. */
3832       if (CLASS_INTERFACE (GET_CPC ()))
3833         flags |= ACC_PUBLIC;
3834     }
3835
3836   /* Push a new context for (static) initialized upon declaration fields */
3837   java_parser_context_push_initialized_field ();
3838
3839   /* Interface modifiers check
3840        - public/abstract allowed (already done at that point)
3841        - abstract is obsolete (comes first, it's a warning, or should be)
3842        - Can't use twice the same (checked in the modifier rule) */
3843   if ((flags & ACC_ABSTRACT) && flag_redundant)
3844     parse_warning_context
3845       (MODIFIER_WFL (ABSTRACT_TK),
3846        "Redundant use of `abstract' modifier. Interface `%s' is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3847
3848   /* Create a new decl if DECL is NULL, otherwise fix it */
3849   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3850
3851   /* Set super info and mark the class a complete */
3852   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3853                   object_type_node, ctxp->interface_number);
3854   ctxp->interface_number = 0;
3855   CLASS_COMPLETE_P (decl) = 1;
3856   add_superinterfaces (decl, super);
3857
3858   /* Eventually sets the @deprecated tag flag */
3859   CHECK_DEPRECATED (decl);
3860
3861   return decl;
3862 }
3863
3864 /* Patch anonymous class CLASS, by either extending or implementing
3865    DEP.  */
3866
3867 static void
3868 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
3869 {
3870   tree class = TREE_TYPE (class_decl);
3871   tree type =  TREE_TYPE (type_decl);
3872   tree binfo = TYPE_BINFO (class);
3873
3874   /* If it's an interface, implement it */
3875   if (CLASS_INTERFACE (type_decl))
3876     {
3877       tree s_binfo;
3878       int length;
3879
3880       if (parser_check_super_interface (type_decl, class_decl, wfl))
3881         return;
3882
3883       s_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0);
3884       length = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (class))+1;
3885       TYPE_BINFO_BASETYPES (class) = make_tree_vec (length);
3886       TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (class)), 0) = s_binfo;
3887       /* And add the interface */
3888       parser_add_interface (class_decl, type_decl, wfl);
3889     }
3890   /* Otherwise, it's a type we want to extend */
3891   else
3892     {
3893       if (parser_check_super (type_decl, class_decl, wfl))
3894         return;
3895       BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), 0)) = type;
3896     }
3897 }
3898
3899 static tree
3900 create_anonymous_class (int location, tree type_name)
3901 {
3902   char buffer [80];
3903   tree super = NULL_TREE, itf = NULL_TREE;
3904   tree id, type_decl, class;
3905
3906   /* The unqualified name of the anonymous class. It's just a number. */
3907   sprintf (buffer, "%d", anonymous_class_counter++);
3908   id = build_wfl_node (get_identifier (buffer));
3909   EXPR_WFL_LINECOL (id) = location;
3910
3911   /* We know about the type to extend/implement. We go ahead */
3912   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
3913     {
3914       /* Create a class which either implements on extends the designated
3915          class. The class bears an inaccessible name. */
3916       if (CLASS_INTERFACE (type_decl))
3917         {
3918           /* It's OK to modify it here. It's been already used and
3919              shouldn't be reused */
3920           ctxp->interface_number = 1;
3921           /* Interfaces should presented as a list of WFLs */
3922           itf = build_tree_list (type_name, NULL_TREE);
3923         }
3924       else
3925         super = type_name;
3926     }
3927
3928   class = create_class (ACC_FINAL, id, super, itf);
3929
3930   /* We didn't know anything about the stuff. We register a dependence. */
3931   if (!type_decl)
3932     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
3933
3934   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
3935   return class;
3936 }
3937
3938 /* Create a class in pass1 and return its decl. Return class
3939    interface's decl in pass 2.  */
3940
3941 static tree
3942 create_class (int flags, tree id, tree super, tree interfaces)
3943 {
3944   tree raw_name = EXPR_WFL_NODE (id);
3945   tree class_id, decl;
3946   tree super_decl_type;
3947
3948   /* Certain syntax errors are making SUPER be like ID. Avoid this
3949      case. */
3950   if (ctxp->class_err && id == super)
3951     super = NULL;
3952
3953   class_id = parser_qualified_classname (raw_name);
3954   decl = IDENTIFIER_CLASS_VALUE (class_id);
3955   EXPR_WFL_NODE (id) = class_id;
3956
3957   /* Basic check: scope, redefinition, modifiers */
3958   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
3959     {
3960       PUSH_ERROR ();
3961       return NULL_TREE;
3962     }
3963
3964   /* Suspend the current parsing context if we're parsing an inner
3965      class or an anonymous class. */
3966   if (CPC_INNER_P ())
3967     {
3968       java_parser_context_suspend ();
3969       /* Interface members are public. */
3970       if (CLASS_INTERFACE (GET_CPC ()))
3971         flags |= ACC_PUBLIC;
3972     }
3973
3974   /* Push a new context for (static) initialized upon declaration fields */
3975   java_parser_context_push_initialized_field ();
3976
3977   /* Class modifier check:
3978        - Allowed modifier (already done at that point)
3979        - abstract AND final forbidden
3980        - Public classes defined in the correct file */
3981   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
3982     parse_error_context
3983       (id, "Class `%s' can't be declared both abstract and final",
3984        IDENTIFIER_POINTER (raw_name));
3985
3986   /* Create a new decl if DECL is NULL, otherwise fix it */
3987   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
3988
3989   /* If SUPER exists, use it, otherwise use Object */
3990   if (super)
3991     {
3992       /* Can't extend java.lang.Object */
3993       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
3994         {
3995           parse_error_context (id, "Can't extend `java.lang.Object'");
3996           return NULL_TREE;
3997         }
3998
3999       super_decl_type =
4000         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4001     }
4002   else if (TREE_TYPE (decl) != object_type_node)
4003     super_decl_type = object_type_node;
4004   /* We're defining java.lang.Object */
4005   else
4006     super_decl_type = NULL_TREE;
4007
4008   /* A class nested in an interface is implicitly static. */
4009   if (INNER_CLASS_DECL_P (decl)
4010       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4011     {
4012       flags |= ACC_STATIC;
4013     }
4014
4015   /* Set super info and mark the class as complete. */
4016   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4017                   ctxp->interface_number);
4018   ctxp->interface_number = 0;
4019   CLASS_COMPLETE_P (decl) = 1;
4020   add_superinterfaces (decl, interfaces);
4021
4022   /* Add the private this$<n> field, Replicate final locals still in
4023      scope as private final fields mangled like val$<local_name>.
4024      This doesn't not occur for top level (static) inner classes. */
4025   if (PURE_INNER_CLASS_DECL_P (decl))
4026     add_inner_class_fields (decl, current_function_decl);
4027
4028   /* If doing xref, store the location at which the inherited class
4029      (if any) was seen. */
4030   if (flag_emit_xref && super)
4031     DECL_INHERITED_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (super);
4032
4033   /* Eventually sets the @deprecated tag flag */
4034   CHECK_DEPRECATED (decl);
4035
4036   /* Reset the anonymous class counter when declaring non inner classes */
4037   if (!INNER_CLASS_DECL_P (decl))
4038     anonymous_class_counter = 1;
4039
4040   return decl;
4041 }
4042
4043 /* End a class declaration: register the statements used to create
4044    finit$ and <clinit>, pop the current class and resume the prior
4045    parser context if necessary.  */
4046
4047 static void
4048 end_class_declaration (int resume)
4049 {
4050   /* If an error occurred, context weren't pushed and won't need to be
4051      popped by a resume. */
4052   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4053
4054   if (GET_CPC () != error_mark_node)
4055     dump_java_tree (TDI_class, GET_CPC ());
4056
4057   java_parser_context_pop_initialized_field ();
4058   POP_CPC ();
4059   if (resume && no_error_occurred)
4060     java_parser_context_resume ();
4061
4062   /* We're ending a class declaration, this is a good time to reset
4063      the interface cout. Note that might have been already done in
4064      create_interface, but if at that time an inner class was being
4065      dealt with, the interface count was reset in a context created
4066      for the sake of handling inner classes declaration. */
4067   ctxp->interface_number = 0;
4068 }
4069
4070 static void
4071 add_inner_class_fields (tree class_decl, tree fct_decl)
4072 {
4073   tree block, marker, f;
4074
4075   f = add_field (TREE_TYPE (class_decl),
4076                  build_current_thisn (TREE_TYPE (class_decl)),
4077                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4078                  ACC_PRIVATE);
4079   FIELD_THISN (f) = 1;
4080
4081   if (!fct_decl)
4082     return;
4083
4084   for (block = GET_CURRENT_BLOCK (fct_decl);
4085        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4086     {
4087       tree decl;
4088       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4089         {
4090           tree name, pname;
4091           tree wfl, init, list;
4092
4093           /* Avoid non final arguments. */
4094           if (!LOCAL_FINAL_P (decl))
4095             continue;
4096
4097           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4098           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4099           wfl = build_wfl_node (name);
4100           init = build_wfl_node (pname);
4101           /* Build an initialization for the field: it will be
4102              initialized by a parameter added to finit$, bearing a
4103              mangled name of the field itself (param$<n>.) The
4104              parameter is provided to finit$ by the constructor
4105              invoking it (hence the constructor will also feature a
4106              hidden parameter, set to the value of the outer context
4107              local at the time the inner class is created.)
4108
4109              Note: we take into account all possible locals that can
4110              be accessed by the inner class. It's actually not trivial
4111              to minimize these aliases down to the ones really
4112              used. One way to do that would be to expand all regular
4113              methods first, then finit$ to get a picture of what's
4114              used.  It works with the exception that we would have to
4115              go back on all constructor invoked in regular methods to
4116              have their invocation reworked (to include the right amount
4117              of alias initializer parameters.)
4118
4119              The only real way around, I think, is a first pass to
4120              identify locals really used in the inner class. We leave
4121              the flag FIELD_LOCAL_ALIAS_USED around for that future
4122              use.
4123
4124              On the other hand, it only affect local inner classes,
4125              whose constructors (and finit$ call) will be featuring
4126              unnecessary arguments. It's easy for a developer to keep
4127              this number of parameter down by using the `final'
4128              keyword only when necessary. For the time being, we can
4129              issue a warning on unnecessary finals. FIXME */
4130           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4131                                    wfl, init);
4132
4133           /* Register the field. The TREE_LIST holding the part
4134              initialized/initializer will be marked ARG_FINAL_P so
4135              that the created field can be marked
4136              FIELD_LOCAL_ALIAS. */
4137           list = build_tree_list (wfl, init);
4138           ARG_FINAL_P (list) = 1;
4139           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4140         }
4141     }
4142
4143   if (!CPC_INITIALIZER_STMT (ctxp))
4144     return;
4145
4146   /* If we ever registered an alias field, insert and marker to
4147      remember where the list ends. The second part of the list (the one
4148      featuring initialized fields) so it can be later reversed to
4149      enforce 8.5. The marker will be removed during that operation. */
4150   marker = build_tree_list (NULL_TREE, NULL_TREE);
4151   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4152   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4153 }
4154
4155 /* Can't use lookup_field () since we don't want to load the class and
4156    can't set the CLASS_LOADED_P flag */
4157
4158 static tree
4159 find_field (tree class, tree name)
4160 {
4161   tree decl;
4162   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4163     {
4164       if (DECL_NAME (decl) == name)
4165         return decl;
4166     }
4167   return NULL_TREE;
4168 }
4169
4170 /* Wrap around lookup_field that doesn't potentially upset the value
4171    of CLASS */
4172
4173 static tree
4174 lookup_field_wrapper (tree class, tree name)
4175 {
4176   tree type = class;
4177   tree decl = NULL_TREE;
4178   java_parser_context_save_global ();
4179
4180   /* Last chance: if we're within the context of an inner class, we
4181      might be trying to access a local variable defined in an outer
4182      context. We try to look for it now. */
4183   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4184     {
4185       tree new_name;
4186       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4187       decl = lookup_field (&type, new_name);
4188       if (decl && decl != error_mark_node)
4189         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4190     }
4191   if (!decl || decl == error_mark_node)
4192     {
4193       type = class;
4194       decl = lookup_field (&type, name);
4195     }
4196
4197   /* If the field still hasn't been found, try the next enclosing context. */
4198   if (!decl && INNER_CLASS_TYPE_P (class))
4199     {
4200       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4201       decl = lookup_field_wrapper (outer_type, name);
4202     }
4203
4204   java_parser_context_restore_global ();
4205   return decl == error_mark_node ? NULL : decl;
4206 }
4207
4208 /* Find duplicate field within the same class declarations and report
4209    the error. Returns 1 if a duplicated field was found, 0
4210    otherwise.  */
4211
4212 static int
4213 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4214 {
4215   /* This might be modified to work with method decl as well */
4216   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4217   if (decl)
4218     {
4219       char *t1 = xstrdup (purify_type_name
4220                          ((TREE_CODE (new_type) == POINTER_TYPE
4221                            && TREE_TYPE (new_type) == NULL_TREE) ?
4222                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4223                           lang_printable_name (new_type, 1)));
4224       /* The type may not have been completed by the time we report
4225          the error */
4226       char *t2 = xstrdup (purify_type_name
4227                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4228                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4229                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4230                           lang_printable_name (TREE_TYPE (decl), 1)));
4231       parse_error_context
4232         (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
4233          t1, IDENTIFIER_POINTER (new_field_name),
4234          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4235          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4236       free (t1);
4237       free (t2);
4238       return 1;
4239     }
4240   return 0;
4241 }
4242
4243 /* Field registration routine. If TYPE doesn't exist, field
4244    declarations are linked to the undefined TYPE dependency list, to
4245    be later resolved in java_complete_class () */
4246
4247 static void
4248 register_fields (int flags, tree type, tree variable_list)
4249 {
4250   tree current, saved_type;
4251   tree class_type = NULL_TREE;
4252   int saved_lineno = input_line;
4253   int must_chain = 0;
4254   tree wfl = NULL_TREE;
4255
4256   if (GET_CPC ())
4257     class_type = TREE_TYPE (GET_CPC ());
4258
4259   if (!class_type || class_type == error_mark_node)
4260     return;
4261
4262   /* If we're adding fields to interfaces, those fields are public,
4263      static, final */
4264   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4265     {
4266       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4267                                  flags, ACC_PUBLIC, "interface field(s)");
4268       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4269                                  flags, ACC_STATIC, "interface field(s)");
4270       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4271                                  flags, ACC_FINAL, "interface field(s)");
4272       check_modifiers ("Illegal interface member modifier `%s'", flags,
4273                        INTERFACE_FIELD_MODIFIERS);
4274       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4275     }
4276
4277   /* Obtain a suitable type for resolution, if necessary */
4278   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4279
4280   /* If TYPE is fully resolved and we don't have a reference, make one */
4281   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4282
4283   for (current = variable_list, saved_type = type; current;
4284        current = TREE_CHAIN (current), type = saved_type)
4285     {
4286       tree real_type;
4287       tree field_decl;
4288       tree cl = TREE_PURPOSE (current);
4289       tree init = TREE_VALUE (current);
4290       tree current_name = EXPR_WFL_NODE (cl);
4291
4292       /* Can't declare non-final static fields in inner classes */
4293       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4294           && !(flags & ACC_FINAL))
4295         parse_error_context
4296           (cl, "Field `%s' can't be static in inner class `%s' unless it is final",
4297            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4298            lang_printable_name (class_type, 0));
4299
4300       /* Process NAME, as it may specify extra dimension(s) for it */
4301       type = build_array_from_name (type, wfl, current_name, &current_name);
4302
4303       /* Type adjustment. We may have just readjusted TYPE because
4304          the variable specified more dimensions. Make sure we have
4305          a reference if we can and don't have one already. Also
4306          change the name if we have an init. */
4307       if (type != saved_type)
4308         {
4309           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4310           if (init)
4311             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4312         }
4313
4314       real_type = GET_REAL_TYPE (type);
4315       /* Check for redeclarations */
4316       if (duplicate_declaration_error_p (current_name, real_type, cl))
4317         continue;
4318
4319       /* Set lineno to the line the field was found and create a
4320          declaration for it. Eventually sets the @deprecated tag flag. */
4321       if (flag_emit_xref)
4322         input_line = EXPR_WFL_LINECOL (cl);
4323       else
4324         input_line = EXPR_WFL_LINENO (cl);
4325       field_decl = add_field (class_type, current_name, real_type, flags);
4326       CHECK_DEPRECATED_NO_RESET (field_decl);
4327
4328       /* If the field denotes a final instance variable, then we
4329          allocate a LANG_DECL_SPECIFIC part to keep track of its
4330          initialization. We also mark whether the field was
4331          initialized upon its declaration. We don't do that if the
4332          created field is an alias to a final local. */
4333       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4334         {
4335           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4336           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4337         }
4338
4339       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4340          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4341          hide parameters to this inner class finit$ and
4342          constructors. It also means that the field isn't final per
4343          say. */
4344       if (ARG_FINAL_P (current))
4345         {
4346           FIELD_LOCAL_ALIAS (field_decl) = 1;
4347           FIELD_FINAL (field_decl) = 0;
4348         }
4349
4350       /* Check if we must chain. */
4351       if (must_chain)
4352         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4353
4354       /* If we have an initialization value tied to the field */
4355       if (init)
4356         {
4357           /* The field is declared static */
4358           if (flags & ACC_STATIC)
4359             {
4360               /* We include the field and its initialization part into
4361                  a list used to generate <clinit>. After <clinit> is
4362                  walked, field initializations will be processed and
4363                  fields initialized with known constants will be taken
4364                  out of <clinit> and have their DECL_INITIAL set
4365                  appropriately. */
4366               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4367               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4368               if (TREE_OPERAND (init, 1)
4369                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4370                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4371             }
4372           /* A non-static field declared with an immediate initialization is
4373              to be initialized in <init>, if any.  This field is remembered
4374              to be processed at the time of the generation of <init>. */
4375           else
4376             {
4377               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4378               SET_CPC_INITIALIZER_STMT (ctxp, init);
4379             }
4380           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4381           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4382         }
4383     }
4384
4385   CLEAR_DEPRECATED;
4386   input_line = saved_lineno;
4387 }
4388
4389 /* Generate finit$, using the list of initialized fields to populate
4390    its body. finit$'s parameter(s) list is adjusted to include the
4391    one(s) used to initialized the field(s) caching outer context
4392    local(s).  */
4393
4394 static tree
4395 generate_finit (tree class_type)
4396 {
4397   int count = 0;
4398   tree list = TYPE_FINIT_STMT_LIST (class_type);
4399   tree mdecl, current, parms;
4400
4401   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4402                                                   class_type, NULL_TREE,
4403                                                   &count);
4404   CRAFTED_PARAM_LIST_FIXUP (parms);
4405   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4406                                     finit_identifier_node, parms);
4407   fix_method_argument_names (parms, mdecl);
4408   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4409                        mdecl, NULL_TREE);
4410   DECL_FUNCTION_NAP (mdecl) = count;
4411   start_artificial_method_body (mdecl);
4412
4413   for (current = list; current; current = TREE_CHAIN (current))
4414     java_method_add_stmt (mdecl,
4415                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4416                                                 current));
4417   end_artificial_method_body (mdecl);
4418   return mdecl;
4419 }
4420
4421 /* Generate a function to run the instance initialization code. The
4422    private method is called `instinit$'. Unless we're dealing with an
4423    anonymous class, we determine whether all ctors of CLASS_TYPE
4424    declare a checked exception in their `throws' clause in order to
4425    see whether it's necessary to encapsulate the instance initializer
4426    statements in a try/catch/rethrow sequence.  */
4427
4428 static tree
4429 generate_instinit (tree class_type)
4430 {
4431   tree current;
4432   tree compound = NULL_TREE;
4433   tree parms = tree_cons (this_identifier_node,
4434                           build_pointer_type (class_type), end_params_node);
4435   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4436                                          void_type_node,
4437                                          instinit_identifier_node, parms);
4438
4439   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4440                        mdecl, NULL_TREE);
4441
4442   /* Gather all the statements in a compound */
4443   for (current = TYPE_II_STMT_LIST (class_type);
4444        current; current = TREE_CHAIN (current))
4445     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4446
4447   /* We need to encapsulate COMPOUND by a try/catch statement to
4448      rethrow exceptions that might occur in the instance initializer.
4449      We do that only if all ctors of CLASS_TYPE are set to catch a
4450      checked exception. This doesn't apply to anonymous classes (since
4451      they don't have declared ctors.) */
4452   if (!ANONYMOUS_CLASS_P (class_type) &&
4453       ctors_unchecked_throws_clause_p (class_type))
4454     {
4455       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4456                                              build1 (THROW_EXPR, NULL_TREE,
4457                                                      build_wfl_node (wpv_id)));
4458       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4459                                                       exception_type_node);
4460     }
4461
4462   start_artificial_method_body (mdecl);
4463   java_method_add_stmt (mdecl, compound);
4464   end_artificial_method_body (mdecl);
4465
4466   return mdecl;
4467 }
4468
4469 /* FIXME */
4470 static tree
4471 build_instinit_invocation (tree class_type)
4472 {
4473   tree to_return = NULL_TREE;
4474
4475   if (TYPE_II_STMT_LIST (class_type))
4476     {
4477       tree parm = build_tree_list (NULL_TREE,
4478                                    build_wfl_node (this_identifier_node));
4479       to_return =
4480         build_method_invocation (build_wfl_node (instinit_identifier_node),
4481                                  parm);
4482     }
4483   return to_return;
4484 }
4485
4486 /* Shared across method_declarator and method_header to remember the
4487    patch stage that was reached during the declaration of the method.
4488    A method DECL is built differently is there is no patch
4489    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4490    pending on the currently defined method.  */
4491
4492 static int patch_stage;
4493
4494 /* Check the method declaration and add the method to its current
4495    class.  If the argument list is known to contain incomplete types,
4496    the method is partially added and the registration will be resume
4497    once the method arguments resolved. If TYPE is NULL, we're dealing
4498    with a constructor.  */
4499
4500 static tree
4501 method_header (int flags, tree type, tree mdecl, tree throws)
4502 {
4503   tree type_wfl = NULL_TREE;
4504   tree meth_name = NULL_TREE;
4505   tree current, orig_arg, this_class = NULL;
4506   tree id, meth;
4507   int saved_lineno;
4508   int constructor_ok = 0, must_chain;
4509   int count;
4510
4511   if (mdecl == error_mark_node)
4512     return error_mark_node;
4513   meth = TREE_VALUE (mdecl);
4514   id = TREE_PURPOSE (mdecl);
4515
4516   check_modifiers_consistency (flags);
4517
4518   if (GET_CPC ())
4519     this_class = TREE_TYPE (GET_CPC ());
4520
4521   if (!this_class || this_class == error_mark_node)
4522     return NULL_TREE;
4523
4524   /* There are some forbidden modifiers for an abstract method and its
4525      class must be abstract as well.  */
4526   if (type && (flags & ACC_ABSTRACT))
4527     {
4528       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4529       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4530       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4531       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4532       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4533       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4534       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4535           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4536         parse_error_context
4537           (id, "Class `%s' must be declared abstract to define abstract method `%s'",
4538            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4539            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4540     }
4541
4542   /* A native method can't be strictfp.  */
4543   if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4544     parse_error_context (id, "native method `%s' can't be strictfp",
4545                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4546   /* No such thing as a transient or volatile method.  */
4547   if ((flags & ACC_TRANSIENT))
4548     parse_error_context (id, "method `%s' can't be transient",
4549                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4550   if ((flags & ACC_VOLATILE))
4551     parse_error_context (id, "method `%s' can't be volatile",
4552                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4553
4554   /* Things to be checked when declaring a constructor */
4555   if (!type)
4556     {
4557       int ec = java_error_count;
4558       /* 8.6: Constructor declarations: we might be trying to define a
4559          method without specifying a return type. */
4560       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4561         parse_error_context
4562           (id, "Invalid method declaration, return type required");
4563       /* 8.6.3: Constructor modifiers */
4564       else
4565         {
4566           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4567           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4568           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4569           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4570           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4571           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4572         }
4573       /* If we found error here, we don't consider it's OK to tread
4574          the method definition as a constructor, for the rest of this
4575          function */
4576       if (ec == java_error_count)
4577         constructor_ok = 1;
4578     }
4579
4580   /* Method declared within the scope of an interface are implicitly
4581      abstract and public. Conflicts with other erroneously provided
4582      modifiers are checked right after. */
4583
4584   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4585     {
4586       /* If FLAGS isn't set because of a modifier, turn the
4587          corresponding modifier WFL to NULL so we issue a warning on
4588          the obsolete use of the modifier */
4589       if (!(flags & ACC_PUBLIC))
4590         MODIFIER_WFL (PUBLIC_TK) = NULL;
4591       if (!(flags & ACC_ABSTRACT))
4592         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4593       flags |= ACC_PUBLIC;
4594       flags |= ACC_ABSTRACT;
4595     }
4596
4597   /* Inner class can't declare static methods */
4598   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4599     {
4600       parse_error_context
4601         (id, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
4602          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4603          lang_printable_name (this_class, 0));
4604     }
4605
4606   /* Modifiers context reset moved up, so abstract method declaration
4607      modifiers can be later checked.  */
4608
4609   /* Set constructor returned type to void and method name to <init>,
4610      unless we found an error identifier the constructor (in which
4611      case we retain the original name) */
4612   if (!type)
4613     {
4614       type = void_type_node;
4615       if (constructor_ok)
4616         meth_name = init_identifier_node;
4617     }
4618   else
4619     meth_name = EXPR_WFL_NODE (id);
4620
4621   /* Do the returned type resolution and registration if necessary */
4622   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4623
4624   if (meth_name)
4625     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4626   EXPR_WFL_NODE (id) = meth_name;
4627   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4628
4629   if (must_chain)
4630     {
4631       patch_stage = JDEP_METHOD_RETURN;
4632       register_incomplete_type (patch_stage, type_wfl, id, type);
4633       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4634     }
4635   else
4636     TREE_TYPE (meth) = type;
4637
4638   saved_lineno = input_line;
4639   /* When defining an abstract or interface method, the curly
4640      bracket at level 1 doesn't exist because there is no function
4641      body */
4642   input_line = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4643             EXPR_WFL_LINENO (id));
4644
4645   /* Remember the original argument list */
4646   orig_arg = TYPE_ARG_TYPES (meth);
4647
4648   if (patch_stage)              /* includes ret type and/or all args */
4649     {
4650       jdep *jdep;
4651       meth = add_method_1 (this_class, flags, meth_name, meth);
4652       /* Patch for the return type */
4653       if (patch_stage == JDEP_METHOD_RETURN)
4654         {
4655           jdep = CLASSD_LAST (ctxp->classd_list);
4656           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4657         }
4658       /* This is the stop JDEP. METH allows the function's signature
4659          to be computed. */
4660       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4661     }
4662   else
4663     meth = add_method (this_class, flags, meth_name,
4664                        build_java_signature (meth));
4665
4666   /* Remember final parameters */
4667   MARK_FINAL_PARMS (meth, orig_arg);
4668
4669   /* Fix the method argument list so we have the argument name
4670      information */
4671   fix_method_argument_names (orig_arg, meth);
4672
4673   /* Register the parameter number and re-install the current line
4674      number */
4675   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4676   input_line = saved_lineno;
4677
4678   /* Register exception specified by the `throws' keyword for
4679      resolution and set the method decl appropriate field to the list.
4680      Note: the grammar ensures that what we get here are class
4681      types. */
4682   if (throws)
4683     {
4684       throws = nreverse (throws);
4685       for (current = throws; current; current = TREE_CHAIN (current))
4686         {
4687           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4688                                     NULL_TREE, NULL_TREE);
4689           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4690             &TREE_VALUE (current);
4691         }
4692       DECL_FUNCTION_THROWS (meth) = throws;
4693     }
4694
4695   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4696     DECL_FUNCTION_WFL (meth) = id;
4697
4698   /* Set the flag if we correctly processed a constructor */
4699   if (constructor_ok)
4700     {
4701       DECL_CONSTRUCTOR_P (meth) = 1;
4702       /* Compute and store the number of artificial parameters declared
4703          for this constructor */
4704       for (count = 0, current = TYPE_FIELDS (this_class); current;
4705            current = TREE_CHAIN (current))
4706         if (FIELD_LOCAL_ALIAS (current))
4707           count++;
4708       DECL_FUNCTION_NAP (meth) = count;
4709     }
4710
4711   /* Eventually set the @deprecated tag flag */
4712   CHECK_DEPRECATED (meth);
4713
4714   /* If doing xref, store column and line number information instead
4715      of the line number only. */
4716   if (flag_emit_xref)
4717     DECL_SOURCE_LINE (meth) = EXPR_WFL_LINECOL (id);
4718
4719   return meth;
4720 }
4721
4722 static void
4723 fix_method_argument_names (tree orig_arg, tree meth)
4724 {
4725   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4726   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4727     {
4728       TREE_PURPOSE (arg) = this_identifier_node;
4729       arg = TREE_CHAIN (arg);
4730     }
4731   while (orig_arg != end_params_node)
4732     {
4733       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4734       orig_arg = TREE_CHAIN (orig_arg);
4735       arg = TREE_CHAIN (arg);
4736     }
4737 }
4738
4739 /* Complete the method declaration with METHOD_BODY.  */
4740
4741 static void
4742 finish_method_declaration (tree method_body)
4743 {
4744   int flags;
4745
4746   if (!current_function_decl)
4747     return;
4748
4749   flags = get_access_flags_from_decl (current_function_decl);
4750
4751   /* 8.4.5 Method Body */
4752   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4753     {
4754       tree name = DECL_NAME (current_function_decl);
4755       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4756                            "%s method `%s' can't have a body defined",
4757                            (METHOD_NATIVE (current_function_decl) ?
4758                             "Native" : "Abstract"),
4759                            IDENTIFIER_POINTER (name));
4760       method_body = NULL_TREE;
4761     }
4762   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4763     {
4764       tree name = DECL_NAME (current_function_decl);
4765       parse_error_context
4766         (DECL_FUNCTION_WFL (current_function_decl),
4767          "Non native and non abstract method `%s' must have a body defined",
4768          IDENTIFIER_POINTER (name));
4769       method_body = NULL_TREE;
4770     }
4771
4772   if (flag_emit_class_files && method_body
4773       && TREE_CODE (method_body) == NOP_EXPR
4774       && TREE_TYPE (current_function_decl)
4775       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4776     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4777
4778   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4779   maybe_absorb_scoping_blocks ();
4780   /* Exit function's body */
4781   exit_block ();
4782   /* Merge last line of the function with first line, directly in the
4783      function decl. It will be used to emit correct debug info. */
4784   if (!flag_emit_xref)
4785     DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4786
4787   /* Since function's argument's list are shared, reset the
4788      ARG_FINAL_P parameter that might have been set on some of this
4789      function parameters. */
4790   UNMARK_FINAL_PARMS (current_function_decl);
4791
4792   /* So we don't have an irrelevant function declaration context for
4793      the next static block we'll see. */
4794   current_function_decl = NULL_TREE;
4795 }
4796
4797 /* Build a an error message for constructor circularity errors.  */
4798
4799 static char *
4800 constructor_circularity_msg (tree from, tree to)
4801 {
4802   static char string [4096];
4803   char *t = xstrdup (lang_printable_name (from, 0));
4804   sprintf (string, "`%s' invokes `%s'", t, lang_printable_name (to, 0));
4805   free (t);
4806   return string;
4807 }
4808
4809 /* Verify a circular call to METH. Return 1 if an error is found, 0
4810    otherwise.  */
4811
4812 static GTY(()) tree vcc_list;
4813 static int
4814 verify_constructor_circularity (tree meth, tree current)
4815 {
4816   tree c;
4817
4818   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4819     {
4820       if (TREE_VALUE (c) == meth)
4821         {
4822           char *t;
4823           if (vcc_list)
4824             {
4825               tree liste;
4826               vcc_list = nreverse (vcc_list);
4827               for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4828                 {
4829                   parse_error_context
4830                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4831                      constructor_circularity_msg
4832                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4833                   java_error_count--;
4834                 }
4835             }
4836           t = xstrdup (lang_printable_name (meth, 0));
4837           parse_error_context (TREE_PURPOSE (c),
4838                                "%s: recursive invocation of constructor `%s'",
4839                                constructor_circularity_msg (current, meth), t);
4840           free (t);
4841           vcc_list = NULL_TREE;
4842           return 1;
4843         }
4844     }
4845   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4846     {
4847       vcc_list = tree_cons (c, current, vcc_list);
4848       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
4849         return 1;
4850       vcc_list = TREE_CHAIN (vcc_list);
4851     }
4852   return 0;
4853 }
4854
4855 /* Check modifiers that can be declared but exclusively */
4856
4857 static void
4858 check_modifiers_consistency (int flags)
4859 {
4860   int acc_count = 0;
4861   tree cl = NULL_TREE;
4862
4863   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
4864   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
4865   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
4866   if (acc_count > 1)
4867     parse_error_context
4868       (cl, "Inconsistent member declaration.  At most one of `public', `private', or `protected' may be specified");
4869
4870   acc_count = 0;
4871   cl = NULL_TREE;
4872   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
4873   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
4874   if (acc_count > 1)
4875     parse_error_context (cl,
4876                          "Inconsistent member declaration.  At most one of `final' or `volatile' may be specified");
4877 }
4878
4879 /* Check the methode header METH for abstract specifics features */
4880
4881 static void
4882 check_abstract_method_header (tree meth)
4883 {
4884   int flags = get_access_flags_from_decl (meth);
4885
4886   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
4887                               ACC_ABSTRACT, "abstract method",
4888                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4889   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
4890                               ACC_PUBLIC, "abstract method",
4891                               IDENTIFIER_POINTER (DECL_NAME (meth)));
4892
4893   check_modifiers ("Illegal modifier `%s' for interface method",
4894                   flags, INTERFACE_METHOD_MODIFIERS);
4895 }
4896
4897 /* Create a FUNCTION_TYPE node and start augmenting it with the
4898    declared function arguments. Arguments type that can't be resolved
4899    are left as they are, but the returned node is marked as containing
4900    incomplete types.  */
4901
4902 static tree
4903 method_declarator (tree id, tree list)
4904 {
4905   tree arg_types = NULL_TREE, current, node;
4906   tree meth = make_node (FUNCTION_TYPE);
4907   jdep *jdep;
4908
4909   patch_stage = JDEP_NO_PATCH;
4910
4911   if (GET_CPC () == error_mark_node)
4912     return error_mark_node;
4913
4914   /* If we're dealing with an inner class constructor, we hide the
4915      this$<n> decl in the name field of its parameter declaration.  We
4916      also might have to hide the outer context local alias
4917      initializers. Not done when the class is a toplevel class. */
4918   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
4919       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
4920     {
4921       tree aliases_list, type, thisn;
4922       /* First the aliases, linked to the regular parameters */
4923       aliases_list =
4924         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
4925                                                 TREE_TYPE (GET_CPC ()),
4926                                                 NULL_TREE, NULL);
4927       list = chainon (nreverse (aliases_list), list);
4928
4929       /* Then this$<n> */
4930       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
4931       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
4932       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
4933                         list);
4934     }
4935
4936   for (current = list; current; current = TREE_CHAIN (current))
4937     {
4938       int must_chain = 0;
4939       tree wfl_name = TREE_PURPOSE (current);
4940       tree type = TREE_VALUE (current);
4941       tree name = EXPR_WFL_NODE (wfl_name);
4942       tree already, arg_node;
4943       tree type_wfl = NULL_TREE;
4944       tree real_type;
4945
4946       /* Obtain a suitable type for resolution, if necessary */
4947       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4948
4949       /* Process NAME, as it may specify extra dimension(s) for it */
4950       type = build_array_from_name (type, type_wfl, name, &name);
4951       EXPR_WFL_NODE (wfl_name) = name;
4952
4953       real_type = GET_REAL_TYPE (type);
4954       if (TREE_CODE (real_type) == RECORD_TYPE)
4955         {
4956           real_type = promote_type (real_type);
4957           if (TREE_CODE (type) == TREE_LIST)
4958             TREE_PURPOSE (type) = real_type;
4959         }
4960
4961       /* Check redefinition */
4962       for (already = arg_types; already; already = TREE_CHAIN (already))
4963         if (TREE_PURPOSE (already) == name)
4964           {
4965             parse_error_context
4966               (wfl_name, "Variable `%s' is used more than once in the argument list of method `%s'",
4967                IDENTIFIER_POINTER (name),
4968                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4969             break;
4970           }
4971
4972       /* If we've an incomplete argument type, we know there is a location
4973          to patch when the type get resolved, later.  */
4974       jdep = NULL;
4975       if (must_chain)
4976         {
4977           patch_stage = JDEP_METHOD;
4978           type = register_incomplete_type (patch_stage,
4979                                            type_wfl, wfl_name, type);
4980           jdep = CLASSD_LAST (ctxp->classd_list);
4981           JDEP_MISC (jdep) = id;
4982         }
4983
4984       /* The argument node: a name and a (possibly) incomplete type.  */
4985       arg_node = build_tree_list (name, real_type);
4986       /* Remember arguments declared final. */
4987       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
4988
4989       if (jdep)
4990         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
4991       TREE_CHAIN (arg_node) = arg_types;
4992       arg_types = arg_node;
4993     }
4994   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
4995   node = build_tree_list (id, meth);
4996   return node;
4997 }
4998
4999 static int
5000 unresolved_type_p (tree wfl, tree *returned)
5001
5002 {
5003   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5004     {
5005       if (returned)
5006         {
5007           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5008           if (decl && current_class && (decl == TYPE_NAME (current_class)))
5009             *returned = TREE_TYPE (decl);
5010           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5011             *returned = TREE_TYPE (GET_CPC ());
5012           else
5013             *returned = NULL_TREE;
5014         }
5015       return 1;
5016     }
5017   if (returned)
5018     *returned = wfl;
5019   return 0;
5020 }
5021
5022 /* From NAME, build a qualified identifier node using the
5023    qualification from the current package definition. */
5024
5025 static tree
5026 parser_qualified_classname (tree name)
5027 {
5028   tree nested_class_name;
5029
5030   if ((nested_class_name = maybe_make_nested_class_name (name)))
5031     return nested_class_name;
5032
5033   if (ctxp->package)
5034     return merge_qualified_name (ctxp->package, name);
5035   else
5036     return name;
5037 }
5038
5039 /* Called once the type a interface extends is resolved. Returns 0 if
5040    everything is OK.  */
5041
5042 static int
5043 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5044 {
5045   tree super_type = TREE_TYPE (super_decl);
5046
5047   /* Has to be an interface */
5048   if (!CLASS_INTERFACE (super_decl))
5049     {
5050       parse_error_context
5051         (this_wfl, "%s `%s' can't implement/extend %s `%s'",
5052          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5053           "Interface" : "Class"),
5054          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5055          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5056          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5057       return 1;
5058     }
5059
5060   /* Check top-level interface access. Inner classes are subject to member
5061      access rules (6.6.1). */
5062   if (! INNER_CLASS_P (super_type)
5063       && check_pkg_class_access (DECL_NAME (super_decl),
5064                                  lookup_cl (this_decl), true))
5065     return 1;
5066
5067   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5068                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5069                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5070   return 0;
5071 }
5072
5073 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5074    0 if everything is OK.  */
5075
5076 static int
5077 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5078 {
5079   tree super_type = TREE_TYPE (super_decl);
5080
5081   /* SUPER should be a CLASS (neither an array nor an interface) */
5082   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5083     {
5084       parse_error_context
5085         (wfl, "Class `%s' can't subclass %s `%s'",
5086          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5087          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5088          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5089       return 1;
5090     }
5091
5092   if (CLASS_FINAL (TYPE_NAME (super_type)))
5093     {
5094       parse_error_context (wfl, "Can't subclass final classes: %s",
5095                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5096       return 1;
5097     }
5098
5099   /* Check top-level class scope. Inner classes are subject to member access
5100      rules (6.6.1). */
5101   if (! INNER_CLASS_P (super_type)
5102       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true)))
5103     return 1;
5104
5105   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5106                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5107                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5108   return 0;
5109 }
5110
5111 /* Create a new dependency list and link it (in a LIFO manner) to the
5112    CTXP list of type dependency list.  */
5113
5114 static void
5115 create_jdep_list (struct parser_ctxt *ctxp)
5116 {
5117   jdeplist *new = xmalloc (sizeof (jdeplist));
5118   new->first = new->last = NULL;
5119   new->next = ctxp->classd_list;
5120   ctxp->classd_list = new;
5121 }
5122
5123 static jdeplist *
5124 reverse_jdep_list (struct parser_ctxt *ctxp)
5125 {
5126   jdeplist *prev = NULL, *current, *next;
5127   for (current = ctxp->classd_list; current; current = next)
5128     {
5129       next = current->next;
5130       current->next = prev;
5131       prev = current;
5132     }
5133   return prev;
5134 }
5135
5136 /* Create a fake pointer based on the ID stored in
5137    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5138    registered again. */
5139
5140 static tree
5141 obtain_incomplete_type (tree type_name)
5142 {
5143   tree ptr = NULL_TREE, name;
5144
5145   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5146     name = EXPR_WFL_NODE (type_name);
5147   else if (INCOMPLETE_TYPE_P (type_name))
5148     name = TYPE_NAME (type_name);
5149   else
5150     abort ();
5151
5152   /* Workaround from build_pointer_type for incomplete types.  */
5153   BUILD_PTR_FROM_NAME (ptr, name);
5154   TYPE_MODE (ptr) = ptr_mode;
5155   layout_type (ptr);
5156
5157   return ptr;
5158 }
5159
5160 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5161    non NULL instead of computing a new fake type based on WFL. The new
5162    dependency is inserted in the current type dependency list, in FIFO
5163    manner.  */
5164
5165 static tree
5166 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5167 {
5168   jdep *new = xmalloc (sizeof (jdep));
5169
5170   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5171     ptr = obtain_incomplete_type (wfl);
5172
5173   JDEP_KIND (new) = kind;
5174   JDEP_DECL (new) = decl;
5175   JDEP_TO_RESOLVE (new) = ptr;
5176   JDEP_WFL (new) = wfl;
5177   JDEP_CHAIN (new) = NULL;
5178   JDEP_MISC (new) = NULL_TREE;
5179   /* For some dependencies, set the enclosing class of the current
5180      class to be the enclosing context */
5181   if ((kind == JDEP_INTERFACE  || kind == JDEP_ANONYMOUS)
5182       && GET_ENCLOSING_CPC ())
5183     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5184   else if (kind == JDEP_SUPER)
5185     JDEP_ENCLOSING (new) = (GET_ENCLOSING_CPC () ?
5186                             TREE_VALUE (GET_ENCLOSING_CPC ()) : NULL_TREE);
5187   else
5188     JDEP_ENCLOSING (new) = GET_CPC ();
5189   JDEP_GET_PATCH (new) = (tree *)NULL;
5190
5191   JDEP_INSERT (ctxp->classd_list, new);
5192
5193   return ptr;
5194 }
5195
5196 /* This checks for circular references with innerclasses. We start
5197    from SOURCE and should never reach TARGET. Extended/implemented
5198    types in SOURCE have their enclosing context checked not to reach
5199    TARGET. When the last enclosing context of SOURCE is reached, its
5200    extended/implemented types are also checked not to reach TARGET.
5201    In case of error, WFL of the offending type is returned; NULL_TREE
5202    otherwise.  */
5203
5204 static tree
5205 check_inner_circular_reference (tree source, tree target)
5206 {
5207   tree basetype_vec = TYPE_BINFO_BASETYPES (source);
5208   tree ctx, cl;
5209   int i;
5210
5211   if (!basetype_vec)
5212     return NULL_TREE;
5213
5214   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5215     {
5216       tree su;
5217
5218       /* We can end up with a NULL_TREE or an incomplete type here if
5219          we encountered previous type resolution errors. It's safe to
5220          simply ignore these cases.  */
5221       if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
5222         continue;
5223       su = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
5224       if (INCOMPLETE_TYPE_P (su))
5225         continue;
5226
5227       if (inherits_from_p (su, target))
5228         return lookup_cl (TYPE_NAME (su));
5229
5230       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5231         {
5232           /* An enclosing context shouldn't be TARGET */
5233           if (ctx == TYPE_NAME (target))
5234             return lookup_cl (TYPE_NAME (su));
5235
5236           /* When we reach the enclosing last context, start a check
5237              on it, with the same target */
5238           if (! DECL_CONTEXT (ctx) &&
5239               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5240             return cl;
5241         }
5242     }
5243   return NULL_TREE;
5244 }
5245
5246 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5247    offending type if a circularity is detected. NULL_TREE is returned
5248    otherwise. TYPE can be an interface or a class.   */
5249
5250 static tree
5251 check_circular_reference (tree type)
5252 {
5253   tree basetype_vec = TYPE_BINFO_BASETYPES (type);
5254   int i;
5255
5256   if (!basetype_vec)
5257     return NULL_TREE;
5258
5259   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5260     {
5261       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5262         return lookup_cl (TYPE_NAME (type));
5263       return NULL_TREE;
5264     }
5265
5266   for (i = 0; i < TREE_VEC_LENGTH (basetype_vec); i++)
5267     {
5268       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
5269       if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
5270           && interface_of_p (type, BINFO_TYPE (vec_elt)))
5271         return lookup_cl (TYPE_NAME (BINFO_TYPE (vec_elt)));
5272     }
5273   return NULL_TREE;
5274 }
5275
5276 void
5277 java_check_circular_reference (void)
5278 {
5279   tree current;
5280   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5281     {
5282       tree type = TREE_TYPE (current);
5283       tree cl;
5284
5285       cl = check_circular_reference (type);
5286       if (! cl)
5287         cl = check_inner_circular_reference (type, type);
5288       if (cl)
5289         parse_error_context (cl, "Cyclic class inheritance%s",
5290                              (cyclic_inheritance_report ?
5291                               cyclic_inheritance_report : ""));
5292     }
5293 }
5294
5295 /* Augment the parameter list PARM with parameters crafted to
5296    initialize outer context locals aliases. Through ARTIFICIAL, a
5297    count is kept of the number of crafted parameters. MODE governs
5298    what eventually gets created: something suitable for a function
5299    creation or a function invocation, either the constructor or
5300    finit$.  */
5301
5302 static tree
5303 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5304                                         int *artificial)
5305 {
5306   tree field;
5307   tree additional_parms = NULL_TREE;
5308
5309   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5310     if (FIELD_LOCAL_ALIAS (field))
5311       {
5312         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5313         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5314         tree mangled_id;
5315
5316         switch (mode)
5317           {
5318           case AIPL_FUNCTION_DECLARATION:
5319             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5320                                                          &buffer [4]);
5321             purpose = build_wfl_node (mangled_id);
5322             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5323               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5324             else
5325               value = TREE_TYPE (field);
5326             break;
5327
5328           case AIPL_FUNCTION_CREATION:
5329             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5330                                                          &buffer [4]);
5331             value = TREE_TYPE (field);
5332             break;
5333
5334           case AIPL_FUNCTION_FINIT_INVOCATION:
5335             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5336                                                          &buffer [4]);
5337             /* Now, this is wrong. purpose should always be the NAME
5338                of something and value its matching value (decl, type,
5339                etc...) FIXME -- but there is a lot to fix. */
5340
5341             /* When invoked for this kind of operation, we already
5342                know whether a field is used or not. */
5343             purpose = TREE_TYPE (field);
5344             value = build_wfl_node (mangled_id);
5345             break;
5346
5347           case AIPL_FUNCTION_CTOR_INVOCATION:
5348             /* There are two case: the constructor invocation happens
5349                outside the local inner, in which case, locales from the outer
5350                context are directly used.
5351
5352                Otherwise, we fold to using the alias directly. */
5353             if (class_type == current_class)
5354               value = field;
5355             else
5356               {
5357                 name = get_identifier (&buffer[4]);
5358                 value = IDENTIFIER_LOCAL_VALUE (name);
5359               }
5360             break;
5361           }
5362         additional_parms = tree_cons (purpose, value, additional_parms);
5363         if (artificial)
5364           *artificial +=1;
5365       }
5366   if (additional_parms)
5367     {
5368       if (ANONYMOUS_CLASS_P (class_type)
5369           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5370         additional_parms = nreverse (additional_parms);
5371       parm = chainon (additional_parms, parm);
5372     }
5373
5374    return parm;
5375 }
5376
5377 /* Craft a constructor for CLASS_DECL -- what we should do when none
5378    where found. ARGS is non NULL when a special signature must be
5379    enforced. This is the case for anonymous classes.  */
5380
5381 static tree
5382 craft_constructor (tree class_decl, tree args)
5383 {
5384   tree class_type = TREE_TYPE (class_decl);
5385   tree parm = NULL_TREE;
5386   int flags = (get_access_flags_from_decl (class_decl) & ACC_PUBLIC ?
5387                ACC_PUBLIC : 0);
5388   int i = 0, artificial = 0;
5389   tree decl, ctor_name;
5390   char buffer [80];
5391
5392   /* The constructor name is <init> unless we're dealing with an
5393      anonymous class, in which case the name will be fixed after having
5394      be expanded. */
5395   if (ANONYMOUS_CLASS_P (class_type))
5396     ctor_name = DECL_NAME (class_decl);
5397   else
5398     ctor_name = init_identifier_node;
5399
5400   /* If we're dealing with an inner class constructor, we hide the
5401      this$<n> decl in the name field of its parameter declaration. */
5402   if (PURE_INNER_CLASS_TYPE_P (class_type))
5403     {
5404       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5405       parm = tree_cons (build_current_thisn (class_type),
5406                         build_pointer_type (type), parm);
5407
5408       /* Some more arguments to be hidden here. The values of the local
5409          variables of the outer context that the inner class needs to see. */
5410       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5411                                                      class_type, parm,
5412                                                      &artificial);
5413     }
5414
5415   /* Then if there are any args to be enforced, enforce them now */
5416   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5417     {
5418       sprintf (buffer, "parm%d", i++);
5419       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5420     }
5421
5422   CRAFTED_PARAM_LIST_FIXUP (parm);
5423   decl = create_artificial_method (class_type, flags, void_type_node,
5424                                    ctor_name, parm);
5425   fix_method_argument_names (parm, decl);
5426   /* Now, mark the artificial parameters. */
5427   DECL_FUNCTION_NAP (decl) = artificial;
5428   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5429   DECL_INLINE (decl) = 1;
5430   return decl;
5431 }
5432
5433
5434 /* Fix the constructors. This will be called right after circular
5435    references have been checked. It is necessary to fix constructors
5436    early even if no code generation will take place for that class:
5437    some generated constructor might be required by the class whose
5438    compilation triggered this one to be simply loaded.  */
5439
5440 void
5441 java_fix_constructors (void)
5442 {
5443   tree current;
5444
5445   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5446     {
5447       tree class_type = TREE_TYPE (current);
5448       int saw_ctor = 0;
5449       tree decl;
5450
5451       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5452         continue;
5453
5454       output_class = current_class = class_type;
5455       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5456         {
5457           if (DECL_CONSTRUCTOR_P (decl))
5458             {
5459               fix_constructors (decl);
5460               saw_ctor = 1;
5461             }
5462         }
5463
5464       /* Anonymous class constructor can't be generated that early. */
5465       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5466         craft_constructor (current, NULL_TREE);
5467     }
5468 }
5469
5470 /* safe_layout_class just makes sure that we can load a class without
5471    disrupting the current_class, input_file, lineno, etc, information
5472    about the class processed currently.  */
5473
5474 void
5475 safe_layout_class (tree class)
5476 {
5477   tree save_current_class = current_class;
5478   location_t save_location = input_location;
5479
5480   layout_class (class);
5481
5482   current_class = save_current_class;
5483   input_location = save_location;
5484 }
5485
5486 static tree
5487 jdep_resolve_class (jdep *dep)
5488 {
5489   tree decl;
5490
5491   if (JDEP_RESOLVED_P (dep))
5492     decl = JDEP_RESOLVED_DECL (dep);
5493   else
5494     {
5495       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5496                             JDEP_DECL (dep), JDEP_WFL (dep));
5497       JDEP_RESOLVED (dep, decl);
5498       /* If there is no WFL, that's ok.  We generate this warning
5499          elsewhere.  */
5500       if (decl && JDEP_WFL (dep) != NULL_TREE)
5501         check_deprecation (JDEP_WFL (dep), decl);
5502     }
5503
5504   if (!decl)
5505     complete_class_report_errors (dep);
5506   else if (PURE_INNER_CLASS_DECL_P (decl))
5507     {
5508       tree inner = TREE_TYPE (decl);
5509       if (! CLASS_LOADED_P (inner))
5510         {
5511           safe_layout_class (inner);
5512           if (TYPE_SIZE (inner) == error_mark_node)
5513             TYPE_SIZE (inner) = NULL_TREE;
5514         }
5515       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5516     }
5517   return decl;
5518 }
5519
5520 /* Complete unsatisfied class declaration and their dependencies */
5521
5522 void
5523 java_complete_class (void)
5524 {
5525   tree cclass;
5526   jdeplist *cclassd;
5527   int error_found;
5528   tree type;
5529
5530   /* Process imports */
5531   process_imports ();
5532
5533   /* Reverse things so we have the right order */
5534   ctxp->class_list = nreverse (ctxp->class_list);
5535   ctxp->classd_list = reverse_jdep_list (ctxp);
5536
5537   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5538        cclass && cclassd;
5539        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5540     {
5541       jdep *dep;
5542
5543       /* We keep the compilation unit imports in the class so that
5544          they can be used later to resolve type dependencies that
5545          aren't necessary to solve now. */
5546       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5547       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5548
5549       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5550         {
5551           tree decl;
5552           if (!(decl = jdep_resolve_class (dep)))
5553             continue;
5554
5555           /* Now it's time to patch */
5556           switch (JDEP_KIND (dep))
5557             {
5558             case JDEP_SUPER:
5559               /* Simply patch super */
5560               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5561                 continue;
5562               BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
5563                 (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
5564               break;
5565
5566             case JDEP_FIELD:
5567               {
5568                 /* We do part of the job done in add_field */
5569                 tree field_decl = JDEP_DECL (dep);
5570                 tree field_type = TREE_TYPE (decl);
5571                 if (TREE_CODE (field_type) == RECORD_TYPE)
5572                   field_type = promote_type (field_type);
5573                 TREE_TYPE (field_decl) = field_type;
5574                 DECL_ALIGN (field_decl) = 0;
5575                 DECL_USER_ALIGN (field_decl) = 0;
5576                 layout_decl (field_decl, 0);
5577                 SOURCE_FRONTEND_DEBUG
5578                   (("Completed field/var decl `%s' with `%s'",
5579                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5580                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5581                 break;
5582               }
5583             case JDEP_METHOD:   /* We start patching a method */
5584             case JDEP_METHOD_RETURN:
5585               error_found = 0;
5586               while (1)
5587                 {
5588                   if (decl)
5589                     {
5590                       type = TREE_TYPE(decl);
5591                       if (TREE_CODE (type) == RECORD_TYPE)
5592                         type = promote_type (type);
5593                       JDEP_APPLY_PATCH (dep, type);
5594                       SOURCE_FRONTEND_DEBUG
5595                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5596                            "Completing fct `%s' with ret type `%s'":
5597                            "Completing arg `%s' with type `%s'"),
5598                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5599                                               (JDEP_DECL_WFL (dep))),
5600                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5601                     }
5602                   else
5603                     error_found = 1;
5604                   dep = JDEP_CHAIN (dep);
5605                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5606                     break;
5607                   else
5608                     decl = jdep_resolve_class (dep);
5609                 }
5610               if (!error_found)
5611                 {
5612                   tree mdecl = JDEP_DECL (dep), signature;
5613                   /* Recompute and reset the signature, check first that
5614                      all types are now defined. If they're not,
5615                      don't build the signature. */
5616                   if (check_method_types_complete (mdecl))
5617                     {
5618                       signature = build_java_signature (TREE_TYPE (mdecl));
5619                       set_java_signature (TREE_TYPE (mdecl), signature);
5620                     }
5621                 }
5622               else
5623                 continue;
5624               break;
5625
5626             case JDEP_INTERFACE:
5627               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5628                                                 JDEP_WFL (dep)))
5629                 continue;
5630               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5631               break;
5632
5633             case JDEP_PARM:
5634             case JDEP_VARIABLE:
5635               type = TREE_TYPE(decl);
5636               if (TREE_CODE (type) == RECORD_TYPE)
5637                 type = promote_type (type);
5638               JDEP_APPLY_PATCH (dep, type);
5639               break;
5640
5641             case JDEP_TYPE:
5642               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5643               SOURCE_FRONTEND_DEBUG
5644                 (("Completing a random type dependency on a '%s' node",
5645                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5646               break;
5647
5648             case JDEP_EXCEPTION:
5649               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5650               SOURCE_FRONTEND_DEBUG
5651                 (("Completing `%s' `throws' argument node",
5652                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5653               break;
5654
5655             case JDEP_ANONYMOUS:
5656               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5657               break;
5658
5659             default:
5660               abort ();
5661             }
5662         }
5663     }
5664   return;
5665 }
5666
5667 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5668    array.  */
5669
5670 static tree
5671 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5672 {
5673   tree tname = TYPE_NAME (class_type);
5674   tree resolved_type = TREE_TYPE (class_type);
5675   int array_dims = 0;
5676   tree resolved_type_decl;
5677
5678   if (resolved_type != NULL_TREE)
5679     {
5680       tree resolved_type_decl = TYPE_NAME (resolved_type);
5681       if (resolved_type_decl == NULL_TREE
5682           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5683         {
5684           resolved_type_decl = build_decl (TYPE_DECL,
5685                                            TYPE_NAME (class_type),
5686                                            resolved_type);
5687         }
5688       return resolved_type_decl;
5689     }
5690
5691   /* 1- Check to see if we have an array. If true, find what we really
5692      want to resolve  */
5693   if ((array_dims = build_type_name_from_array_name (tname,
5694                                                      &TYPE_NAME (class_type))))
5695     WFL_STRIP_BRACKET (cl, cl);
5696
5697   /* 2- Resolve the bare type */
5698   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5699                                                decl, cl)))
5700     return NULL_TREE;
5701   resolved_type = TREE_TYPE (resolved_type_decl);
5702
5703   /* 3- If we have an array, reconstruct the array down to its nesting */
5704   if (array_dims)
5705     {
5706       for (; array_dims; array_dims--)
5707         resolved_type = build_java_array_type (resolved_type, -1);
5708       resolved_type_decl = TYPE_NAME (resolved_type);
5709     }
5710   TREE_TYPE (class_type) = resolved_type;
5711   return resolved_type_decl;
5712 }
5713
5714 /* Effectively perform the resolution of class CLASS_TYPE.  DECL or CL
5715    are used to report error messages; CL must either be NULL_TREE or a
5716    WFL wrapping a class.  Do not try to replace TYPE_NAME (class_type)
5717    by a variable, since it is changed by find_in_imports{_on_demand}
5718    and (but it doesn't really matter) qualify_and_find.  */
5719
5720 tree
5721 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5722 {
5723   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5724   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5725   tree decl_result;
5726   htab_t circularity_hash;
5727
5728   if (QUALIFIED_P (TYPE_NAME (class_type)))
5729     {
5730       /* If the type name is of the form `Q . Id', then Q is either a
5731          package name or a class name.  First we try to find Q as a
5732          class and then treat Id as a member type.  If we can't find Q
5733          as a class then we fall through.  */
5734       tree q, left, left_type, right;
5735       if (breakdown_qualified (&left, &right, TYPE_NAME (class_type)) == 0)
5736         {
5737           BUILD_PTR_FROM_NAME (left_type, left);
5738           q = do_resolve_class (enclosing, left_type, decl, cl);
5739           if (q)
5740             {
5741               enclosing = q;
5742               saved_enclosing_type = TREE_TYPE (q);
5743               BUILD_PTR_FROM_NAME (class_type, right);
5744             }
5745         }
5746     }
5747
5748   if (enclosing)
5749     {
5750       /* This hash table is used to register the classes we're going
5751          through when searching the current class as an inner class, in
5752          order to detect circular references. Remember to free it before
5753          returning the section 0- of this function. */
5754       circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5755                                       NULL);
5756
5757       /* 0- Search in the current class as an inner class.
5758          Maybe some code here should be added to load the class or
5759          something, at least if the class isn't an inner class and ended
5760          being loaded from class file. FIXME. */
5761       while (enclosing)
5762         {
5763           new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5764                                                 &super, class_type);
5765           if (new_class_decl)
5766             break;
5767
5768           /* If we haven't found anything because SUPER reached Object and
5769              ENCLOSING happens to be an innerclass, try the enclosing context. */
5770           if ((!super || super == object_type_node) &&
5771               enclosing && INNER_CLASS_DECL_P (enclosing))
5772             enclosing = DECL_CONTEXT (enclosing);
5773           else
5774             enclosing = NULL_TREE;
5775         }
5776
5777       htab_delete (circularity_hash);
5778
5779       if (new_class_decl)
5780         return new_class_decl;
5781     }
5782
5783   /* 1- Check for the type in single imports. This will change
5784      TYPE_NAME() if something relevant is found */
5785   find_in_imports (saved_enclosing_type, class_type);
5786
5787   /* 2- And check for the type in the current compilation unit */
5788   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5789     {
5790       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5791           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5792         load_class (TYPE_NAME (class_type), 0);
5793       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5794     }
5795
5796   /* 3- Search according to the current package definition */
5797   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5798     {
5799       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5800                                              TYPE_NAME (class_type))))
5801         return new_class_decl;
5802     }
5803
5804   /* 4- Check the import on demands. Don't allow bar.baz to be
5805      imported from foo.* */
5806   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5807     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5808       return NULL_TREE;
5809
5810   /* If found in find_in_imports_on_demand, the type has already been
5811      loaded. */
5812   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5813     return new_class_decl;
5814
5815   /* 5- Try with a name qualified with the package name we've seen so far */
5816   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5817     {
5818       tree package;
5819
5820       /* If there is a current package (ctxp->package), it's the first
5821          element of package_list and we can skip it. */
5822       for (package = (ctxp->package ?
5823                       TREE_CHAIN (package_list) : package_list);
5824            package; package = TREE_CHAIN (package))
5825         if ((new_class_decl = qualify_and_find (class_type,
5826                                                TREE_PURPOSE (package),
5827                                                TYPE_NAME (class_type))))
5828           return new_class_decl;
5829     }
5830
5831   /* 5- Check another compilation unit that bears the name of type */
5832   load_class (TYPE_NAME (class_type), 0);
5833
5834   if (!cl)
5835     cl = lookup_cl (decl);
5836
5837   /* If we don't have a value for CL, then we're being called recursively.
5838      We can't check package access just yet, but it will be taken care of
5839      by the caller. */
5840   if (cl)
5841     {
5842       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true))
5843         return NULL_TREE;
5844     }
5845
5846   /* 6- Last call for a resolution */
5847   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5848
5849   /* The final lookup might have registered a.b.c into a.b$c If we
5850      failed at the first lookup, progressively change the name if
5851      applicable and use the matching DECL instead. */
5852   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5853     {
5854       char *separator;
5855       tree name = TYPE_NAME (class_type);
5856       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
5857
5858       strcpy (namebuffer, IDENTIFIER_POINTER (name));
5859
5860       do {
5861
5862        /* Reach the last '.', and if applicable, replace it by a `$' and
5863           see if this exists as a type. */
5864        if ((separator = strrchr (namebuffer, '.')))
5865          {
5866            *separator = '$';
5867            name = get_identifier (namebuffer);
5868            decl_result = IDENTIFIER_CLASS_VALUE (name);
5869          }
5870       } while (!decl_result && separator);
5871     }
5872   return decl_result;
5873 }
5874
5875 static tree
5876 qualify_and_find (tree class_type, tree package, tree name)
5877 {
5878   tree new_qualified = merge_qualified_name (package, name);
5879   tree new_class_decl;
5880
5881   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
5882     load_class (new_qualified, 0);
5883   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
5884     {
5885       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
5886           !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
5887         load_class (new_qualified, 0);
5888       TYPE_NAME (class_type) = new_qualified;
5889       return IDENTIFIER_CLASS_VALUE (new_qualified);
5890     }
5891   return NULL_TREE;
5892 }
5893
5894 /* Resolve NAME and lay it out (if not done and if not the current
5895    parsed class). Return a decl node. This function is meant to be
5896    called when type resolution is necessary during the walk pass.  */
5897
5898 static tree
5899 resolve_and_layout (tree something, tree cl)
5900 {
5901   tree decl, decl_type;
5902
5903   /* Don't do that on the current class */
5904   if (something == current_class)
5905     return TYPE_NAME (current_class);
5906
5907   /* Don't do anything for void and other primitive types */
5908   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5909     return NULL_TREE;
5910
5911   /* Pointer types can be reall pointer types or fake pointers. When
5912      finding a real pointer, recheck for primitive types */
5913   if (TREE_CODE (something) == POINTER_TYPE)
5914     {
5915       if (TREE_TYPE (something))
5916         {
5917           something = TREE_TYPE (something);
5918           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
5919             return NULL_TREE;
5920         }
5921       else
5922         something = TYPE_NAME (something);
5923     }
5924
5925   /* Don't do anything for arrays of primitive types */
5926   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
5927       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
5928     return NULL_TREE;
5929
5930   /* Something might be a WFL */
5931   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
5932     something = EXPR_WFL_NODE (something);
5933
5934   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
5935      TYPE_DECL or a real TYPE */
5936   else if (TREE_CODE (something) != IDENTIFIER_NODE)
5937     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
5938             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
5939
5940   if (!(decl = resolve_no_layout (something, cl)))
5941     return NULL_TREE;
5942
5943   /* Resolve and layout if necessary */
5944   decl_type = TREE_TYPE (decl);
5945   layout_class_methods (decl_type);
5946   /* Check methods */
5947   if (CLASS_FROM_SOURCE_P (decl_type))
5948     java_check_methods (decl);
5949   /* Layout the type if necessary */
5950   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
5951     safe_layout_class (decl_type);
5952
5953   return decl;
5954 }
5955
5956 /* Resolve a class, returns its decl but doesn't perform any
5957    layout. The current parsing context is saved and restored */
5958
5959 static tree
5960 resolve_no_layout (tree name, tree cl)
5961 {
5962   tree ptr, decl;
5963   BUILD_PTR_FROM_NAME (ptr, name);
5964   java_parser_context_save_global ();
5965   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
5966   java_parser_context_restore_global ();
5967
5968   return decl;
5969 }
5970
5971 /* Called when reporting errors. Skip the '[]'s in a complex array
5972    type description that failed to be resolved. purify_type_name can't
5973    use an identifier tree.  */
5974
5975 static const char *
5976 purify_type_name (const char *name)
5977 {
5978   int len = strlen (name);
5979   int bracket_found;
5980
5981   STRING_STRIP_BRACKETS (name, len, bracket_found);
5982   if (bracket_found)
5983     {
5984       char *stripped_name = xmemdup (name, len, len+1);
5985       stripped_name [len] = '\0';
5986       return stripped_name;
5987     }
5988   return name;
5989 }
5990
5991 /* The type CURRENT refers to can't be found. We print error messages.  */
5992
5993 static void
5994 complete_class_report_errors (jdep *dep)
5995 {
5996   const char *name;
5997
5998   if (!JDEP_WFL (dep))
5999     return;
6000
6001   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6002   switch (JDEP_KIND (dep))
6003     {
6004     case JDEP_SUPER:
6005       parse_error_context
6006         (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
6007          purify_type_name (name),
6008          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6009       break;
6010     case JDEP_FIELD:
6011       parse_error_context
6012         (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
6013          purify_type_name (name),
6014          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6015       break;
6016     case JDEP_METHOD:           /* Covers arguments */
6017       parse_error_context
6018         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the argument `%s' of method `%s'",
6019          purify_type_name (name),
6020          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6021          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6022       break;
6023     case JDEP_METHOD_RETURN:    /* Covers return type */
6024       parse_error_context
6025         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the return type of method `%s'",
6026          purify_type_name (name),
6027          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6028       break;
6029     case JDEP_INTERFACE:
6030       parse_error_context
6031         (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
6032          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6033          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6034          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6035       break;
6036     case JDEP_VARIABLE:
6037       parse_error_context
6038         (JDEP_WFL (dep), "Type `%s' not found in the declaration of the local variable `%s'",
6039          purify_type_name (IDENTIFIER_POINTER
6040                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6041          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6042       break;
6043     case JDEP_EXCEPTION:        /* As specified by `throws' */
6044       parse_error_context
6045           (JDEP_WFL (dep), "Class `%s' not found in `throws'",
6046          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6047       break;
6048     default:
6049       /* Fix for -Wall. Just break doing nothing. The error will be
6050          caught later */
6051       break;
6052     }
6053 }
6054
6055 /* Return a static string containing the DECL prototype string. If
6056    DECL is a constructor, use the class name instead of the form
6057    <init> */
6058
6059 static const char *
6060 get_printable_method_name (tree decl)
6061 {
6062   const char *to_return;
6063   tree name = NULL_TREE;
6064
6065   if (DECL_CONSTRUCTOR_P (decl))
6066     {
6067       name = DECL_NAME (decl);
6068       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6069     }
6070
6071   to_return = lang_printable_name (decl, 0);
6072   if (DECL_CONSTRUCTOR_P (decl))
6073     DECL_NAME (decl) = name;
6074
6075   return to_return;
6076 }
6077
6078 /* Track method being redefined inside the same class. As a side
6079    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6080    function it's a FWL, so we can track errors more accurately.)  */
6081
6082 static int
6083 check_method_redefinition (tree class, tree method)
6084 {
6085   tree redef, sig;
6086
6087   /* There's no need to verify <clinit> and finit$ and instinit$ */
6088   if (DECL_CLINIT_P (method)
6089       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6090     return 0;
6091
6092   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6093   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6094     {
6095       if (redef == method)
6096         break;
6097       if (DECL_NAME (redef) == DECL_NAME (method)
6098           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6099           && !DECL_ARTIFICIAL (method))
6100         {
6101           parse_error_context
6102             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration `%s'",
6103              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6104              get_printable_method_name (redef));
6105           return 1;
6106         }
6107     }
6108   return 0;
6109 }
6110
6111 /* Return 1 if check went ok, 0 otherwise.  */
6112 static int
6113 check_abstract_method_definitions (int do_interface, tree class_decl,
6114                                    tree type)
6115 {
6116   tree class = TREE_TYPE (class_decl);
6117   tree method, end_type;
6118   int ok = 1;
6119
6120   end_type = (do_interface ? object_type_node : type);
6121   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6122     {
6123       tree other_super, other_method, method_sig, method_name;
6124       int found = 0;
6125       int end_type_reached = 0;
6126
6127       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6128         continue;
6129
6130       /* Now verify that somewhere in between TYPE and CLASS,
6131          abstract method METHOD gets a non abstract definition
6132          that is inherited by CLASS.  */
6133
6134       method_sig = build_java_signature (TREE_TYPE (method));
6135       method_name = DECL_NAME (method);
6136       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6137         method_name = EXPR_WFL_NODE (method_name);
6138
6139       other_super = class;
6140       do {
6141         if (other_super == end_type)
6142           end_type_reached = 1;
6143
6144         /* Method search */
6145         for (other_method = TYPE_METHODS (other_super); other_method;
6146             other_method = TREE_CHAIN (other_method))
6147           {
6148             tree s = build_java_signature (TREE_TYPE (other_method));
6149             tree other_name = DECL_NAME (other_method);
6150
6151             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6152               other_name = EXPR_WFL_NODE (other_name);
6153             if (!DECL_CLINIT_P (other_method)
6154                 && !DECL_CONSTRUCTOR_P (other_method)
6155                 && method_name == other_name
6156                 && method_sig == s
6157                 && !METHOD_ABSTRACT (other_method))
6158              {
6159                found = 1;
6160                break;
6161              }
6162           }
6163         other_super = CLASSTYPE_SUPER (other_super);
6164       } while (!end_type_reached);
6165
6166       /* Report that abstract METHOD didn't find an implementation
6167          that CLASS can use. */
6168       if (!found)
6169         {
6170           char *t = xstrdup (lang_printable_name
6171                             (TREE_TYPE (TREE_TYPE (method)), 0));
6172           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6173
6174           parse_error_context
6175             (lookup_cl (class_decl),
6176              "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",
6177              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6178              t, lang_printable_name (method, 0),
6179              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6180               "interface" : "class"),
6181              IDENTIFIER_POINTER (ccn),
6182              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6183              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6184           ok = 0;
6185           free (t);
6186         }
6187     }
6188
6189   if (ok && do_interface)
6190     {
6191       /* Check for implemented interfaces. */
6192       int i;
6193       tree vector = TYPE_BINFO_BASETYPES (type);
6194       for (i = 1; ok && vector && i < TREE_VEC_LENGTH (vector); i++)
6195         {
6196           tree super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6197           ok = check_abstract_method_definitions (1, class_decl, super);
6198         }
6199     }
6200
6201   return ok;
6202 }
6203
6204 /* Check that CLASS_DECL somehow implements all inherited abstract
6205    methods.  */
6206
6207 static void
6208 java_check_abstract_method_definitions (tree class_decl)
6209 {
6210   tree class = TREE_TYPE (class_decl);
6211   tree super, vector;
6212   int i;
6213
6214   if (CLASS_ABSTRACT (class_decl))
6215     return;
6216
6217   /* Check for inherited types */
6218   super = class;
6219   do {
6220     super = CLASSTYPE_SUPER (super);
6221     check_abstract_method_definitions (0, class_decl, super);
6222   } while (super != object_type_node);
6223
6224   /* Check for implemented interfaces. */
6225   vector = TYPE_BINFO_BASETYPES (class);
6226   for (i = 1; i < TREE_VEC_LENGTH (vector); i++)
6227     {
6228       super = BINFO_TYPE (TREE_VEC_ELT (vector, i));
6229       check_abstract_method_definitions (1, class_decl, super);
6230     }
6231 }
6232
6233 /* Check all the types method DECL uses and return 1 if all of them
6234    are now complete, 0 otherwise. This is used to check whether its
6235    safe to build a method signature or not.  */
6236
6237 static int
6238 check_method_types_complete (tree decl)
6239 {
6240   tree type = TREE_TYPE (decl);
6241   tree args;
6242
6243   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6244     return 0;
6245
6246   args = TYPE_ARG_TYPES (type);
6247   if (TREE_CODE (type) == METHOD_TYPE)
6248     args = TREE_CHAIN (args);
6249   for (; args != end_params_node; args = TREE_CHAIN (args))
6250     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6251       return 0;
6252
6253   return 1;
6254 }
6255
6256 /* Visible interface to check methods contained in CLASS_DECL */
6257
6258 void
6259 java_check_methods (tree class_decl)
6260 {
6261   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6262     return;
6263
6264   if (CLASS_INTERFACE (class_decl))
6265     java_check_abstract_methods (class_decl);
6266   else
6267     java_check_regular_methods (class_decl);
6268
6269   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6270 }
6271
6272 /* Like not_accessible_p, but doesn't refer to the current class at
6273    all.  */
6274 static bool
6275 hack_is_accessible_p (tree member, tree from_where)
6276 {
6277   int flags = get_access_flags_from_decl (member);
6278
6279   if (from_where == DECL_CONTEXT (member)
6280       || (flags & ACC_PUBLIC))
6281     return true;
6282
6283   if ((flags & ACC_PROTECTED))
6284     {
6285       if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6286         return true;
6287     }
6288
6289   if ((flags & ACC_PRIVATE))
6290     return false;
6291
6292   /* Package private, or protected.  */
6293   return in_same_package (TYPE_NAME (from_where),
6294                           TYPE_NAME (DECL_CONTEXT (member)));
6295 }
6296
6297 /* Check all the methods of CLASS_DECL. Methods are first completed
6298    then checked according to regular method existence rules.  If no
6299    constructor for CLASS_DECL were encountered, then build its
6300    declaration.  */
6301 static void
6302 java_check_regular_methods (tree class_decl)
6303 {
6304   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6305   tree method;
6306   tree class = TREE_TYPE (class_decl);
6307   tree found = NULL_TREE;
6308   tree mthrows;
6309
6310   /* It is not necessary to check methods defined in java.lang.Object */
6311   if (class == object_type_node)
6312     return;
6313
6314   if (!TYPE_NVIRTUALS (class))
6315     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6316
6317   /* Should take interfaces into account. FIXME */
6318   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6319     {
6320       tree sig;
6321       tree method_wfl = DECL_FUNCTION_WFL (method);
6322       int aflags;
6323
6324       /* Check for redefinitions */
6325       if (check_method_redefinition (class, method))
6326         continue;
6327
6328       /* We verify things thrown by the method.  They must inherit from
6329          java.lang.Throwable.  */
6330       for (mthrows = DECL_FUNCTION_THROWS (method);
6331            mthrows; mthrows = TREE_CHAIN (mthrows))
6332         {
6333           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6334             parse_error_context
6335               (TREE_PURPOSE (mthrows), "Class `%s' in `throws' clause must be a subclass of class `java.lang.Throwable'",
6336                IDENTIFIER_POINTER
6337                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6338         }
6339
6340       /* If we see one constructor a mark so we don't generate the
6341          default one.  Also skip other verifications: constructors
6342          can't be inherited hence hidden or overridden.  */
6343       if (DECL_CONSTRUCTOR_P (method))
6344         {
6345           saw_constructor = 1;
6346           continue;
6347         }
6348
6349       sig = build_java_argument_signature (TREE_TYPE (method));
6350       found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6351                                               SEARCH_SUPER | SEARCH_INTERFACE);
6352
6353       /* Inner class can't declare static methods */
6354       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6355         {
6356           char *t = xstrdup (lang_printable_name (class, 0));
6357           parse_error_context
6358             (method_wfl, "Method `%s' can't be static in inner class `%s'. Only members of interfaces and top-level classes can be static",
6359              lang_printable_name (method, 0), t);
6360           free (t);
6361         }
6362
6363       /* Nothing overrides or it's a private method. */
6364       if (!found)
6365         continue;
6366       if (METHOD_PRIVATE (found))
6367         {
6368           found = NULL_TREE;
6369           continue;
6370         }
6371
6372       /* If `found' is declared in an interface, make sure the
6373          modifier matches. */
6374       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6375           && clinit_identifier_node != DECL_NAME (found)
6376           && !METHOD_PUBLIC (method))
6377         {
6378           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6379           parse_error_context (method_wfl, "Class `%s' must override `%s' with a public method in order to implement interface `%s'",
6380                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6381                                lang_printable_name (method, 0),
6382                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6383         }
6384
6385       /* Can't override a method with the same name and different return
6386          types. */
6387       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6388         {
6389           char *t = xstrdup
6390             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6391           parse_error_context
6392             (method_wfl,
6393              "Method `%s' was defined with return type `%s' in class `%s'",
6394              lang_printable_name (found, 0), t,
6395              IDENTIFIER_POINTER
6396                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6397           free (t);
6398         }
6399
6400       aflags = get_access_flags_from_decl (found);
6401
6402       /* Can't override final. Can't override static. */
6403       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6404         {
6405           /* Static *can* override static */
6406           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6407             continue;
6408           parse_error_context
6409             (method_wfl,
6410              "%s methods can't be overridden. Method `%s' is %s in class `%s'",
6411              (METHOD_FINAL (found) ? "Final" : "Static"),
6412              lang_printable_name (found, 0),
6413              (METHOD_FINAL (found) ? "final" : "static"),
6414              IDENTIFIER_POINTER
6415                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6416           continue;
6417         }
6418
6419       /* Static method can't override instance method. */
6420       if (METHOD_STATIC (method))
6421         {
6422           parse_error_context
6423             (method_wfl,
6424              "Instance methods can't be overridden by a static method. Method `%s' is an instance method in class `%s'",
6425              lang_printable_name (found, 0),
6426              IDENTIFIER_POINTER
6427                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6428           continue;
6429         }
6430
6431       /* - Overriding/hiding public must be public
6432          - Overriding/hiding protected must be protected or public
6433          - If the overridden or hidden method has default (package)
6434            access, then the overriding or hiding method must not be
6435            private; otherwise, a compile-time error occurs.  If
6436            `found' belongs to an interface, things have been already
6437            taken care of.  */
6438       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6439           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6440               || (METHOD_PROTECTED (found)
6441                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6442               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6443                   && METHOD_PRIVATE (method))))
6444         {
6445           parse_error_context
6446             (method_wfl,
6447              "Methods can't be overridden to be more private. Method `%s' is not %s in class `%s'", lang_printable_name (method, 0),
6448              (METHOD_PUBLIC (method) ? "public" :
6449               (METHOD_PRIVATE (method) ? "private" : "protected")),
6450              IDENTIFIER_POINTER (DECL_NAME
6451                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6452           continue;
6453         }
6454
6455       /* Check this method against all the other implementations it
6456          overrides.  Here we only check the class hierarchy; the rest
6457          of the checking is done later.  If this method is just a
6458          Miranda method, we can skip the check.  */
6459       if (! METHOD_INVISIBLE (method))
6460         check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6461     }
6462
6463   /* The above throws clause check only looked at superclasses.  Now
6464      we must also make sure that all methods declared in interfaces
6465      have compatible throws clauses.  FIXME: there are more efficient
6466      ways to organize this checking; we should implement one.  */
6467   check_interface_throws_clauses (class, class);
6468
6469   if (!TYPE_NVIRTUALS (class))
6470     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6471
6472   /* Search for inherited abstract method not yet implemented in this
6473      class.  */
6474   java_check_abstract_method_definitions (class_decl);
6475
6476   if (!saw_constructor)
6477     abort ();
6478 }
6479
6480 /* Check to make sure that all the methods in all the interfaces
6481    implemented by CLASS_DECL are compatible with the concrete
6482    implementations available in CHECK_CLASS_DECL.  */
6483 static void
6484 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6485 {
6486   for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6487     {
6488       tree bases;
6489       int iface_len;
6490       int i;
6491
6492       if (! CLASS_LOADED_P (class_decl))
6493         {
6494           if (CLASS_FROM_SOURCE_P (class_decl))
6495             safe_layout_class (class_decl);
6496           else
6497             load_class (class_decl, 1);
6498         }
6499
6500       bases = TYPE_BINFO_BASETYPES (class_decl);
6501       iface_len = TREE_VEC_LENGTH (bases) - 1;
6502       for (i = iface_len; i > 0; --i)
6503         {
6504           tree interface = BINFO_TYPE (TREE_VEC_ELT (bases, i));
6505           tree iface_method;
6506
6507           for (iface_method = TYPE_METHODS (interface);
6508                iface_method != NULL_TREE;
6509                iface_method = TREE_CHAIN (iface_method))
6510             {
6511               tree sig, method;
6512
6513               /* First look for a concrete method implemented or
6514                  inherited by this class.  No need to search
6515                  interfaces here, since we're already looking through
6516                  all of them.  */
6517               sig = build_java_argument_signature (TREE_TYPE (iface_method));
6518               method
6519                 = lookup_argument_method_generic (check_class_decl,
6520                                                   DECL_NAME (iface_method),
6521                                                   sig, SEARCH_VISIBLE);
6522               /* If we don't find an implementation, that is ok.  Any
6523                  potential errors from that are diagnosed elsewhere.
6524                  Also, multiple inheritance with conflicting throws
6525                  clauses is fine in the absence of a concrete
6526                  implementation.  */
6527               if (method != NULL_TREE && !METHOD_ABSTRACT (method))
6528                 {
6529                   tree method_wfl = DECL_FUNCTION_WFL (method);
6530                   check_throws_clauses (method, method_wfl, iface_method);
6531                 }
6532             }
6533
6534           /* Now check superinterfaces.  */
6535           check_interface_throws_clauses (check_class_decl, interface);
6536         }
6537     }
6538 }
6539
6540 /* Check throws clauses of a method against the clauses of all the
6541    methods it overrides.  We do this by searching up the class
6542    hierarchy, examining all matching accessible methods.  */
6543 static void
6544 check_concrete_throws_clauses (tree class, tree self_method,
6545                                tree name, tree signature)
6546 {
6547   tree method = lookup_argument_method_generic (class, name, signature,
6548                                                 SEARCH_SUPER | SEARCH_VISIBLE);
6549   while (method != NULL_TREE)
6550     {
6551       if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6552         check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6553                               method);
6554
6555       method = lookup_argument_method_generic (DECL_CONTEXT (method),
6556                                                name, signature,
6557                                                SEARCH_SUPER | SEARCH_VISIBLE);
6558     }
6559 }
6560
6561 /* Generate an error if the `throws' clause of METHOD (if any) is
6562    incompatible with the `throws' clause of FOUND (if any).  */
6563 static void
6564 check_throws_clauses (tree method, tree method_wfl, tree found)
6565 {
6566   tree mthrows;
6567
6568   /* Can't check these things with class loaded from bytecode. FIXME */
6569   if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (found)))
6570     return;
6571
6572   for (mthrows = DECL_FUNCTION_THROWS (method);
6573        mthrows; mthrows = TREE_CHAIN (mthrows))
6574     {
6575       tree fthrows;
6576
6577       /* We don't verify unchecked expressions */
6578       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6579         continue;
6580       /* Checked expression must be compatible */
6581       for (fthrows = DECL_FUNCTION_THROWS (found);
6582            fthrows; fthrows = TREE_CHAIN (fthrows))
6583         {
6584           if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6585             break;
6586         }
6587       if (!fthrows)
6588         {
6589           parse_error_context
6590             (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'",
6591              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6592              lang_printable_name (found, 0),
6593              IDENTIFIER_POINTER
6594              (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6595         }
6596     }
6597 }
6598
6599 /* Check abstract method of interface INTERFACE */
6600 static void
6601 java_check_abstract_methods (tree interface_decl)
6602 {
6603   int i, n;
6604   tree method, basetype_vec, found;
6605   tree interface = TREE_TYPE (interface_decl);
6606
6607   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6608     {
6609       /* 2- Check for double definition inside the defining interface */
6610       if (check_method_redefinition (interface, method))
6611         continue;
6612
6613       /* 3- Overriding is OK as far as we preserve the return type.  */
6614       found = lookup_java_interface_method2 (interface, method);
6615       if (found)
6616         {
6617           char *t;
6618           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 0));
6619           parse_error_context
6620             (DECL_FUNCTION_WFL (found),
6621              "Method `%s' was defined with return type `%s' in class `%s'",
6622              lang_printable_name (found, 0), t,
6623              IDENTIFIER_POINTER
6624                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6625           free (t);
6626           continue;
6627         }
6628     }
6629
6630   /* 4- Inherited methods can't differ by their returned types */
6631   if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
6632     return;
6633   n = TREE_VEC_LENGTH (basetype_vec);
6634   for (i = 0; i < n; i++)
6635     {
6636       tree sub_interface_method, sub_interface;
6637       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
6638       if (!vec_elt)
6639         continue;
6640       sub_interface = BINFO_TYPE (vec_elt);
6641       for (sub_interface_method = TYPE_METHODS (sub_interface);
6642            sub_interface_method;
6643            sub_interface_method = TREE_CHAIN (sub_interface_method))
6644         {
6645           found = lookup_java_interface_method2 (interface,
6646                                                  sub_interface_method);
6647           if (found && (found != sub_interface_method))
6648             {
6649               parse_error_context
6650                 (lookup_cl (sub_interface_method),
6651                  "Interface `%s' inherits method `%s' from interface `%s'. This method is redefined with a different return type in interface `%s'",
6652                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6653                  lang_printable_name (found, 0),
6654                  IDENTIFIER_POINTER
6655                    (DECL_NAME (TYPE_NAME
6656                                (DECL_CONTEXT (sub_interface_method)))),
6657                  IDENTIFIER_POINTER
6658                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6659             }
6660         }
6661     }
6662 }
6663
6664 /* Lookup methods in interfaces using their name and partial
6665    signature. Return a matching method only if their types differ.  */
6666
6667 static tree
6668 lookup_java_interface_method2 (tree class, tree method_decl)
6669 {
6670   int i, n;
6671   tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
6672
6673   if (!basetype_vec)
6674     return NULL_TREE;
6675
6676   n = TREE_VEC_LENGTH (basetype_vec);
6677   for (i = 0; i < n; i++)
6678     {
6679       tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
6680       if ((BINFO_TYPE (vec_elt) != object_type_node)
6681           && (to_return =
6682               lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
6683         return to_return;
6684     }
6685   for (i = 0; i < n; i++)
6686     {
6687       to_return = lookup_java_interface_method2
6688         (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
6689       if (to_return)
6690         return to_return;
6691     }
6692
6693   return NULL_TREE;
6694 }
6695
6696 /* Lookup method using their name and partial signature. Return a
6697    matching method only if their types differ.  */
6698
6699 static tree
6700 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6701 {
6702   tree method, method_signature, method_name, method_type, name;
6703
6704   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6705   name = DECL_NAME (method_decl);
6706   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6707                  EXPR_WFL_NODE (name) : name);
6708   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6709
6710   while (clas != NULL_TREE)
6711     {
6712       for (method = TYPE_METHODS (clas);
6713            method != NULL_TREE;  method = TREE_CHAIN (method))
6714         {
6715           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6716           tree name = DECL_NAME (method);
6717           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6718                EXPR_WFL_NODE (name) : name) == method_name
6719               && method_sig == method_signature
6720               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6721             return method;
6722         }
6723       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6724     }
6725   return NULL_TREE;
6726 }
6727
6728 /* Return the line that matches DECL line number, and try its best to
6729    position the column number. Used during error reports.  */
6730
6731 static GTY(()) tree cl_v;
6732 static tree
6733 lookup_cl (tree decl)
6734 {
6735   char *line, *found;
6736
6737   if (!decl)
6738     return NULL_TREE;
6739
6740   if (cl_v == NULL_TREE)
6741     {
6742       cl_v = build_expr_wfl (NULL_TREE, NULL, 0, 0);
6743     }
6744
6745   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6746   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6747
6748   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6749                             EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6750
6751   found = strstr ((const char *)line,
6752                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6753   if (found)
6754     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6755
6756   return cl_v;
6757 }
6758
6759 /* Look for a simple name in the single-type import list */
6760
6761 static tree
6762 find_name_in_single_imports (tree name)
6763 {
6764   tree node;
6765
6766   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6767     if (TREE_VALUE (node) == name)
6768       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6769
6770   return NULL_TREE;
6771 }
6772
6773 /* Process all single-type import. */
6774
6775 static int
6776 process_imports (void)
6777 {
6778   tree import;
6779   int error_found;
6780
6781   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6782     {
6783       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6784       char *original_name;
6785
6786       original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6787                                IDENTIFIER_LENGTH (to_be_found),
6788                                IDENTIFIER_LENGTH (to_be_found) + 1);
6789
6790       /* Don't load twice something already defined. */
6791       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6792         continue;
6793
6794       while (1)
6795         {
6796           tree left;
6797
6798           QUALIFIED_P (to_be_found) = 1;
6799           load_class (to_be_found, 0);
6800           error_found =
6801             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true);
6802
6803           /* We found it, we can bail out */
6804           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6805             {
6806               check_deprecation (TREE_PURPOSE (import),
6807                                  IDENTIFIER_CLASS_VALUE (to_be_found));
6808               break;
6809             }
6810
6811           /* We haven't found it. Maybe we're trying to access an
6812              inner class.  The only way for us to know is to try again
6813              after having dropped a qualifier. If we can't break it further,
6814              we have an error. */
6815           if (breakdown_qualified (&left, NULL, to_be_found))
6816             break;
6817
6818           to_be_found = left;
6819         }
6820       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6821         {
6822           parse_error_context (TREE_PURPOSE (import),
6823                                "Class or interface `%s' not found in import",
6824                                original_name);
6825           error_found = 1;
6826         }
6827
6828       free (original_name);
6829       if (error_found)
6830         return 1;
6831     }
6832   return 0;
6833 }
6834
6835 /* Possibly find and mark a class imported by a single-type import
6836    statement.  */
6837
6838 static void
6839 find_in_imports (tree enclosing_type, tree class_type)
6840 {
6841   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6842                  ctxp->import_list);
6843   while (import)
6844     {
6845       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6846         {
6847           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6848           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6849           return;
6850         }
6851       import = TREE_CHAIN (import);
6852     }
6853 }
6854
6855 static int
6856 note_possible_classname (const char *name, int len)
6857 {
6858   tree node;
6859   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6860     len = len - 5;
6861   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6862     len = len - 6;
6863   else
6864     return 0;
6865   node = ident_subst (name, len, "", '/', '.', "");
6866   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6867   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
6868   return 1;
6869 }
6870
6871 /* Read a import directory, gathering potential match for further type
6872    references. Indifferently reads a filesystem or a ZIP archive
6873    directory.  */
6874
6875 static void
6876 read_import_dir (tree wfl)
6877 {
6878   tree package_id = EXPR_WFL_NODE (wfl);
6879   const char *package_name = IDENTIFIER_POINTER (package_id);
6880   int package_length = IDENTIFIER_LENGTH (package_id);
6881   DIR *dirp = NULL;
6882   JCF *saved_jcf = current_jcf;
6883
6884   int found = 0;
6885   int k;
6886   void *entry;
6887   struct buffer filename[1];
6888
6889   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
6890     return;
6891   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
6892
6893   BUFFER_INIT (filename);
6894   buffer_grow (filename, package_length + 100);
6895
6896   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
6897     {
6898       const char *entry_name = jcf_path_name (entry);
6899       int entry_length = strlen (entry_name);
6900       if (jcf_path_is_zipfile (entry))
6901         {
6902           ZipFile *zipf;
6903           buffer_grow (filename, entry_length);
6904           memcpy (filename->data, entry_name, entry_length - 1);
6905           filename->data[entry_length-1] = '\0';
6906           zipf = opendir_in_zip (filename->data, jcf_path_is_system (entry));
6907           if (zipf == NULL)
6908             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
6909           else
6910             {
6911               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
6912               BUFFER_RESET (filename);
6913               for (k = 0; k < package_length; k++)
6914                 {
6915                   char ch = package_name[k];
6916                   *filename->ptr++ = ch == '.' ? '/' : ch;
6917                 }
6918               *filename->ptr++ = '/';
6919
6920               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
6921                 {
6922                   const char *current_entry = ZIPDIR_FILENAME (zipd);
6923                   int current_entry_len = zipd->filename_length;
6924
6925                   if (current_entry_len >= BUFFER_LENGTH (filename)
6926                       && strncmp (filename->data, current_entry,
6927                                   BUFFER_LENGTH (filename)) != 0)
6928                     continue;
6929                   found |= note_possible_classname (current_entry,
6930                                                     current_entry_len);
6931                 }
6932             }
6933         }
6934       else
6935         {
6936           BUFFER_RESET (filename);
6937           buffer_grow (filename, entry_length + package_length + 4);
6938           strcpy (filename->data, entry_name);
6939           filename->ptr = filename->data + entry_length;
6940           for (k = 0; k < package_length; k++)
6941             {
6942               char ch = package_name[k];
6943               *filename->ptr++ = ch == '.' ? '/' : ch;
6944             }
6945           *filename->ptr = '\0';
6946
6947           dirp = opendir (filename->data);
6948           if (dirp == NULL)
6949             continue;
6950           *filename->ptr++ = '/';
6951           for (;;)
6952             {
6953               int len;
6954               const char *d_name;
6955               struct dirent *direntp = readdir (dirp);
6956               if (!direntp)
6957                 break;
6958               d_name = direntp->d_name;
6959               len = strlen (direntp->d_name);
6960               buffer_grow (filename, len+1);
6961               strcpy (filename->ptr, d_name);
6962               found |= note_possible_classname (filename->data + entry_length,
6963                                                 package_length+len+1);
6964             }
6965           if (dirp)
6966             closedir (dirp);
6967         }
6968     }
6969
6970   free (filename->data);
6971
6972   /* Here we should have a unified way of retrieving an entry, to be
6973      indexed. */
6974   if (!found)
6975     {
6976       static int first = 1;
6977       if (first)
6978         {
6979           error ("Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives", package_name);
6980           java_error_count++;
6981           first = 0;
6982         }
6983       else
6984         parse_error_context (wfl, "Package `%s' not found in import",
6985                              package_name);
6986       current_jcf = saved_jcf;
6987       return;
6988     }
6989   current_jcf = saved_jcf;
6990 }
6991
6992 /* Possibly find a type in the import on demands specified
6993    types. Returns 1 if an error occurred, 0 otherwise. Run through the
6994    entire list, to detected potential double definitions.  */
6995
6996 static int
6997 find_in_imports_on_demand (tree enclosing_type, tree class_type)
6998 {
6999   tree class_type_name = TYPE_NAME (class_type);
7000   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
7001                   ctxp->import_demand_list);
7002   tree cl = NULL_TREE;
7003   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
7004   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
7005   tree node;
7006
7007   for (; import; import = TREE_CHAIN (import))
7008     {
7009       int saved_lineno = input_line;
7010       int access_check;
7011       const char *id_name;
7012       tree decl, type_name_copy;
7013
7014       obstack_grow (&temporary_obstack,
7015                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
7016                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
7017       obstack_1grow (&temporary_obstack, '.');
7018       obstack_grow0 (&temporary_obstack,
7019                      IDENTIFIER_POINTER (class_type_name),
7020                      IDENTIFIER_LENGTH (class_type_name));
7021       id_name = obstack_finish (&temporary_obstack);
7022
7023       if (! (node = maybe_get_identifier (id_name)))
7024         continue;
7025
7026       /* Setup lineno so that it refers to the line of the import (in
7027          case we parse a class file and encounter errors */
7028       input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
7029
7030       type_name_copy = TYPE_NAME (class_type);
7031       TYPE_NAME (class_type) = node;
7032       QUALIFIED_P (node) = 1;
7033       decl = IDENTIFIER_CLASS_VALUE (node);
7034       access_check = -1;
7035       /* If there is no DECL set for the class or if the class isn't
7036          loaded and not seen in source yet, then load */
7037       if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
7038                     && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
7039         {
7040           load_class (node, 0);
7041           decl = IDENTIFIER_CLASS_VALUE (node);
7042         }
7043       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7044         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7045                                                false);
7046       else
7047         /* 6.6.1: Inner classes are subject to member access rules. */
7048         access_check = 0;
7049
7050       input_line = saved_lineno;
7051
7052       /* If the loaded class is not accessible or couldn't be loaded,
7053          we restore the original TYPE_NAME and process the next
7054          import. */
7055       if (access_check || !decl)
7056         {
7057           TYPE_NAME (class_type) = type_name_copy;
7058           continue;
7059         }
7060
7061       /* If the loaded class is accessible, we keep a tab on it to
7062          detect and report multiple inclusions. */
7063       if (IS_A_CLASSFILE_NAME (node))
7064         {
7065           if (seen_once < 0)
7066             {
7067               cl = TREE_PURPOSE (import);
7068               seen_once = 1;
7069             }
7070           else if (seen_once >= 0)
7071             {
7072               tree location = (cl ? cl : TREE_PURPOSE (import));
7073               tree package = (cl ? EXPR_WFL_NODE (cl) :
7074                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
7075               seen_once++;
7076               parse_error_context
7077                 (location,
7078                  "Type `%s' also potentially defined in package `%s'",
7079                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7080                  IDENTIFIER_POINTER (package));
7081             }
7082         }
7083       to_return = access_check;
7084     }
7085
7086   if (seen_once == 1)
7087     return to_return;
7088   else
7089     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7090 }
7091
7092 /* Add package NAME to the list of packages encountered so far. To
7093    speed up class lookup in do_resolve_class, we make sure a
7094    particular package is added only once.  */
7095
7096 static void
7097 register_package (tree name)
7098 {
7099   static htab_t pht;
7100   void **e;
7101
7102   if (pht == NULL)
7103     pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
7104
7105   e = htab_find_slot (pht, name, INSERT);
7106   if (*e == NULL)
7107     {
7108       package_list = chainon (package_list, build_tree_list (name, NULL));
7109       *e = name;
7110     }
7111 }
7112
7113 static tree
7114 resolve_package (tree pkg, tree *next, tree *type_name)
7115 {
7116   tree current;
7117   tree decl = NULL_TREE;
7118   *type_name = NULL_TREE;
7119
7120   /* The trick is to determine when the package name stops and were
7121      the name of something contained in the package starts. Then we
7122      return a fully qualified name of what we want to get. */
7123
7124   *next = EXPR_WFL_QUALIFICATION (pkg);
7125
7126   /* Try to progressively construct a type name */
7127   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7128     for (current = EXPR_WFL_QUALIFICATION (pkg);
7129          current; current = TREE_CHAIN (current))
7130       {
7131         /* If we don't have what we're expecting, exit now. TYPE_NAME
7132            will be null and the error caught later. */
7133         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7134           break;
7135         *type_name =
7136           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7137         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7138           {
7139             /* resolve_package should be used in a loop, hence we
7140                point at this one to naturally process the next one at
7141                the next iteration. */
7142             *next = current;
7143             break;
7144           }
7145       }
7146   return decl;
7147 }
7148
7149
7150 /* Check accessibility of inner classes according to member access rules.
7151    DECL is the inner class, ENCLOSING_DECL is the class from which the
7152    access is being attempted. */
7153
7154 static void
7155 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7156 {
7157   const char *access;
7158   tree enclosing_decl_type;
7159
7160   /* We don't issue an error message when CL is null. CL can be null
7161      as a result of processing a JDEP crafted by source_start_java_method
7162      for the purpose of patching its parm decl. But the error would
7163      have been already trapped when fixing the method's signature.
7164      DECL can also be NULL in case of earlier errors. */
7165   if (!decl || !cl)
7166     return;
7167
7168   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7169
7170   if (CLASS_PRIVATE (decl))
7171     {
7172       /* Access is permitted only within the body of the top-level
7173          class in which DECL is declared. */
7174       tree top_level = decl;
7175       while (DECL_CONTEXT (top_level))
7176         top_level = DECL_CONTEXT (top_level);
7177       while (DECL_CONTEXT (enclosing_decl))
7178         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7179       if (top_level == enclosing_decl)
7180         return;
7181       access = "private";
7182     }
7183   else if (CLASS_PROTECTED (decl))
7184     {
7185       tree decl_context;
7186       /* Access is permitted from within the same package... */
7187       if (in_same_package (decl, enclosing_decl))
7188         return;
7189
7190       /* ... or from within the body of a subtype of the context in which
7191          DECL is declared. */
7192       decl_context = DECL_CONTEXT (decl);
7193       while (enclosing_decl)
7194         {
7195           if (CLASS_INTERFACE (decl))
7196             {
7197               if (interface_of_p (TREE_TYPE (decl_context),
7198                                   enclosing_decl_type))
7199                 return;
7200             }
7201           else
7202             {
7203               /* Eww. The order of the arguments is different!! */
7204               if (inherits_from_p (enclosing_decl_type,
7205                                    TREE_TYPE (decl_context)))
7206                 return;
7207             }
7208           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7209         }
7210       access = "protected";
7211     }
7212   else if (! CLASS_PUBLIC (decl))
7213     {
7214       /* Access is permitted only from within the same package as DECL. */
7215       if (in_same_package (decl, enclosing_decl))
7216         return;
7217       access = "non-public";
7218     }
7219   else
7220     /* Class is public. */
7221     return;
7222
7223   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7224                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7225                        lang_printable_name (decl, 0), access);
7226 }
7227
7228 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7229    foreign package, it must be PUBLIC. Return 0 if no access
7230    violations were found, 1 otherwise. If VERBOSE is true and an error
7231    was found, it is reported and accounted for.  */
7232
7233 static int
7234 check_pkg_class_access (tree class_name, tree cl, bool verbose)
7235 {
7236   tree type;
7237
7238   if (!IDENTIFIER_CLASS_VALUE (class_name))
7239     return 0;
7240
7241   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7242     return 0;
7243
7244   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7245     {
7246       /* Access to a private class within the same package is
7247          allowed. */
7248       tree l, r;
7249       breakdown_qualified (&l, &r, class_name);
7250       if (!QUALIFIED_P (class_name) && !ctxp->package)
7251         /* Both in the empty package. */
7252         return 0;
7253       if (l == ctxp->package)
7254         /* Both in the same package. */
7255         return 0;
7256
7257       if (verbose)
7258         parse_error_context
7259           (cl, "Can't access %s `%s'. Only public classes and interfaces in other packages can be accessed",
7260            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7261            IDENTIFIER_POINTER (class_name));
7262       return 1;
7263     }
7264   return 0;
7265 }
7266
7267 /* Local variable declaration. */
7268
7269 static void
7270 declare_local_variables (int modifier, tree type, tree vlist)
7271 {
7272   tree decl, current, saved_type;
7273   tree type_wfl = NULL_TREE;
7274   int must_chain = 0;
7275   int final_p = 0;
7276
7277   /* Push a new block if statements were seen between the last time we
7278      pushed a block and now. Keep a count of blocks to close */
7279   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7280     {
7281       tree b = enter_block ();
7282       BLOCK_IS_IMPLICIT (b) = 1;
7283     }
7284
7285   if (modifier)
7286     {
7287       size_t i;
7288       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7289         if (1 << i & modifier)
7290           break;
7291       if (modifier == ACC_FINAL)
7292         final_p = 1;
7293       else
7294         {
7295           parse_error_context
7296             (ctxp->modifier_ctx [i],
7297              "Only `final' is allowed as a local variables modifier");
7298           return;
7299         }
7300     }
7301
7302   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7303      hold the TYPE value if a new incomplete has to be created (as
7304      opposed to being found already existing and reused). */
7305   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7306
7307   /* If TYPE is fully resolved and we don't have a reference, make one */
7308   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7309
7310   /* Go through all the declared variables */
7311   for (current = vlist, saved_type = type; current;
7312        current = TREE_CHAIN (current), type = saved_type)
7313     {
7314       tree other, real_type;
7315       tree wfl  = TREE_PURPOSE (current);
7316       tree name = EXPR_WFL_NODE (wfl);
7317       tree init = TREE_VALUE (current);
7318
7319       /* Process NAME, as it may specify extra dimension(s) for it */
7320       type = build_array_from_name (type, type_wfl, name, &name);
7321
7322       /* Variable redefinition check */
7323       if ((other = lookup_name_in_blocks (name)))
7324         {
7325           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7326                                        DECL_SOURCE_LINE (other));
7327           continue;
7328         }
7329
7330       /* Type adjustment. We may have just readjusted TYPE because
7331          the variable specified more dimensions. Make sure we have
7332          a reference if we can and don't have one already. */
7333       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7334
7335       real_type = GET_REAL_TYPE (type);
7336       /* Never layout this decl. This will be done when its scope
7337          will be entered */
7338       decl = build_decl (VAR_DECL, name, real_type);
7339       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7340       DECL_FINAL (decl) = final_p;
7341       BLOCK_CHAIN_DECL (decl);
7342
7343       /* If doing xreferencing, replace the line number with the WFL
7344          compound value */
7345       if (flag_emit_xref)
7346         DECL_SOURCE_LINE (decl) = EXPR_WFL_LINECOL (wfl);
7347
7348       /* Don't try to use an INIT statement when an error was found */
7349       if (init && java_error_count)
7350         init = NULL_TREE;
7351
7352       /* Add the initialization function to the current function's code */
7353       if (init)
7354         {
7355           /* Name might have been readjusted */
7356           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7357           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7358           java_method_add_stmt (current_function_decl,
7359                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7360                                                       init));
7361         }
7362
7363       /* Setup dependency the type of the decl */
7364       if (must_chain)
7365         {
7366           jdep *dep;
7367           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7368           dep = CLASSD_LAST (ctxp->classd_list);
7369           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7370         }
7371     }
7372   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7373 }
7374
7375 /* Called during parsing. Build decls from argument list.  */
7376
7377 static void
7378 source_start_java_method (tree fndecl)
7379 {
7380   tree tem;
7381   tree parm_decl;
7382   int i;
7383
7384   if (!fndecl)
7385     return;
7386
7387   current_function_decl = fndecl;
7388
7389   /* New scope for the function */
7390   enter_block ();
7391   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7392        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7393     {
7394       tree type = TREE_VALUE (tem);
7395       tree name = TREE_PURPOSE (tem);
7396
7397       /* If type is incomplete. Create an incomplete decl and ask for
7398          the decl to be patched later */
7399       if (INCOMPLETE_TYPE_P (type))
7400         {
7401           jdep *jdep;
7402           tree real_type = GET_REAL_TYPE (type);
7403           parm_decl = build_decl (PARM_DECL, name, real_type);
7404           type = obtain_incomplete_type (type);
7405           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7406           jdep = CLASSD_LAST (ctxp->classd_list);
7407           JDEP_MISC (jdep) = name;
7408           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7409         }
7410       else
7411         parm_decl = build_decl (PARM_DECL, name, type);
7412
7413       /* Remember if a local variable was declared final (via its
7414          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7415       if (ARG_FINAL_P (tem))
7416         {
7417           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7418           DECL_FINAL (parm_decl) = 1;
7419         }
7420
7421       BLOCK_CHAIN_DECL (parm_decl);
7422     }
7423   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7424   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7425     nreverse (tem);
7426   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7427   DECL_MAX_LOCALS (current_function_decl) = i;
7428 }
7429
7430 /* Called during parsing. Creates an artificial method declaration.  */
7431
7432 static tree
7433 create_artificial_method (tree class, int flags, tree type,
7434                           tree name, tree args)
7435 {
7436   tree mdecl;
7437
7438   java_parser_context_save_global ();
7439   input_line = 0;
7440   mdecl = make_node (FUNCTION_TYPE);
7441   TREE_TYPE (mdecl) = type;
7442   TYPE_ARG_TYPES (mdecl) = args;
7443   mdecl = add_method (class, flags, name, build_java_signature (mdecl));
7444   java_parser_context_restore_global ();
7445   DECL_ARTIFICIAL (mdecl) = 1;
7446   return mdecl;
7447 }
7448
7449 /* Starts the body if an artificial method.  */
7450
7451 static void
7452 start_artificial_method_body (tree mdecl)
7453 {
7454   DECL_SOURCE_LINE (mdecl) = 1;
7455   DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7456   source_start_java_method (mdecl);
7457   enter_block ();
7458 }
7459
7460 static void
7461 end_artificial_method_body (tree mdecl)
7462 {
7463   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7464      It has to be evaluated first. (if mdecl is current_function_decl,
7465      we have an undefined behavior if no temporary variable is used.) */
7466   tree b = exit_block ();
7467   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7468   exit_block ();
7469 }
7470
7471 /* Dump a tree of some kind.  This is a convenience wrapper for the
7472    dump_* functions in tree-dump.c.  */
7473 static void
7474 dump_java_tree (enum tree_dump_index phase, tree t)
7475 {
7476   FILE *stream;
7477   int flags;
7478
7479   stream = dump_begin (phase, &flags);
7480   flags |= TDF_SLIM;
7481   if (stream)
7482     {
7483       dump_node (t, flags, stream);
7484       dump_end (phase, stream);
7485     }
7486 }
7487
7488 /* Terminate a function and expand its body.  */
7489
7490 static void
7491 source_end_java_method (void)
7492 {
7493   tree fndecl = current_function_decl;
7494
7495   if (!fndecl)
7496     return;
7497
7498   java_parser_context_save_global ();
7499   input_line = ctxp->last_ccb_indent1;
7500
7501   /* Turn function bodies with only a NOP expr null, so they don't get
7502      generated at all and we won't get warnings when using the -W
7503      -Wall flags. */
7504   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) == empty_stmt_node)
7505     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7506
7507   /* We've generated all the trees for this function, and it has been
7508      patched.  Dump it to a file if the user requested it.  */
7509   dump_java_tree (TDI_original, fndecl);
7510
7511   /* Defer expanding the method until cgraph analysis is complete.  */
7512   if (DECL_SAVED_TREE (fndecl))
7513     cgraph_finalize_function (fndecl, false);
7514
7515   current_function_decl = NULL_TREE;
7516   java_parser_context_restore_global ();
7517 }
7518
7519 /* Record EXPR in the current function block. Complements compound
7520    expression second operand if necessary.  */
7521
7522 tree
7523 java_method_add_stmt (tree fndecl, tree expr)
7524 {
7525   if (!GET_CURRENT_BLOCK (fndecl))
7526     return NULL_TREE;
7527   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7528 }
7529
7530 static tree
7531 add_stmt_to_block (tree b, tree type, tree stmt)
7532 {
7533   tree body = BLOCK_EXPR_BODY (b), c;
7534
7535   if (java_error_count)
7536     return body;
7537
7538   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7539     return body;
7540
7541   BLOCK_EXPR_BODY (b) = c;
7542   TREE_SIDE_EFFECTS (c) = 1;
7543   return c;
7544 }
7545
7546 /* Add STMT to EXISTING if possible, otherwise create a new
7547    COMPOUND_EXPR and add STMT to it. */
7548
7549 static tree
7550 add_stmt_to_compound (tree existing, tree type, tree stmt)
7551 {
7552   if (existing)
7553     return build (COMPOUND_EXPR, type, existing, stmt);
7554   else
7555     return stmt;
7556 }
7557
7558 void java_layout_seen_class_methods (void)
7559 {
7560   tree previous_list = all_class_list;
7561   tree end = NULL_TREE;
7562   tree current;
7563
7564   while (1)
7565     {
7566       for (current = previous_list;
7567            current != end; current = TREE_CHAIN (current))
7568         layout_class_methods (TREE_TYPE (TREE_VALUE (current)));
7569
7570       if (previous_list != all_class_list)
7571         {
7572           end = previous_list;
7573           previous_list = all_class_list;
7574         }
7575       else
7576         break;
7577     }
7578 }
7579
7580 static GTY(()) tree stop_reordering;
7581 void
7582 java_reorder_fields (void)
7583 {
7584   tree current;
7585
7586   for (current = gclass_list; current; current = TREE_CHAIN (current))
7587     {
7588       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7589
7590       if (current_class == stop_reordering)
7591         break;
7592
7593       /* Reverse the fields, but leave the dummy field in front.
7594          Fields are already ordered for Object and Class */
7595       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7596           && current_class != class_type_node)
7597       {
7598         /* If the dummy field is there, reverse the right fields and
7599            just layout the type for proper fields offset */
7600         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7601           {
7602             tree fields = TYPE_FIELDS (current_class);
7603             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7604             TYPE_SIZE (current_class) = NULL_TREE;
7605           }
7606         /* We don't have a dummy field, we need to layout the class,
7607            after having reversed the fields */
7608         else
7609           {
7610             TYPE_FIELDS (current_class) =
7611               nreverse (TYPE_FIELDS (current_class));
7612             TYPE_SIZE (current_class) = NULL_TREE;
7613           }
7614       }
7615     }
7616   /* There are cases were gclass_list will be empty. */
7617   if (gclass_list)
7618     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7619 }
7620
7621 /* Layout the methods of all classes loaded in one way or another.
7622    Check methods of source parsed classes. Then reorder the
7623    fields and layout the classes or the type of all source parsed
7624    classes */
7625
7626 void
7627 java_layout_classes (void)
7628 {
7629   tree current;
7630   int save_error_count = java_error_count;
7631
7632   /* Layout the methods of all classes seen so far */
7633   java_layout_seen_class_methods ();
7634   java_parse_abort_on_error ();
7635   all_class_list = NULL_TREE;
7636
7637   /* Then check the methods of all parsed classes */
7638   for (current = gclass_list; current; current = TREE_CHAIN (current))
7639     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7640       java_check_methods (TREE_VALUE (current));
7641   java_parse_abort_on_error ();
7642
7643   for (current = gclass_list; current; current = TREE_CHAIN (current))
7644     {
7645       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7646       layout_class (current_class);
7647
7648       /* Error reported by the caller */
7649       if (java_error_count)
7650         return;
7651     }
7652
7653   /* We might have reloaded classes durign the process of laying out
7654      classes for code generation. We must layout the methods of those
7655      late additions, as constructor checks might use them */
7656   java_layout_seen_class_methods ();
7657   java_parse_abort_on_error ();
7658 }
7659
7660 /* Expand methods in the current set of classes remembered for
7661    generation.  */
7662
7663 static void
7664 java_complete_expand_classes (void)
7665 {
7666   tree current;
7667
7668   do_not_fold = flag_emit_xref;
7669
7670   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7671     if (!INNER_CLASS_DECL_P (current))
7672       java_complete_expand_class (current);
7673 }
7674
7675 /* Expand the methods found in OUTER, starting first by OUTER's inner
7676    classes, if any.  */
7677
7678 static void
7679 java_complete_expand_class (tree outer)
7680 {
7681   tree inner_list;
7682
7683   set_nested_class_simple_name_value (outer, 1); /* Set */
7684
7685   /* We need to go after all inner classes and start expanding them,
7686      starting with most nested ones. We have to do that because nested
7687      classes might add functions to outer classes */
7688
7689   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7690        inner_list; inner_list = TREE_CHAIN (inner_list))
7691     java_complete_expand_class (TREE_PURPOSE (inner_list));
7692
7693   java_complete_expand_methods (outer);
7694   set_nested_class_simple_name_value (outer, 0); /* Reset */
7695 }
7696
7697 /* Expand methods registered in CLASS_DECL. The general idea is that
7698    we expand regular methods first. This allows us get an estimate on
7699    how outer context local alias fields are really used so we can add
7700    to the constructor just enough code to initialize them properly (it
7701    also lets us generate finit$ correctly.) Then we expand the
7702    constructors and then <clinit>.  */
7703
7704 static void
7705 java_complete_expand_methods (tree class_decl)
7706 {
7707   tree clinit, decl, first_decl;
7708
7709   output_class = current_class = TREE_TYPE (class_decl);
7710
7711   /* Pre-expand <clinit> to figure whether we really need it or
7712      not. If we do need it, we pre-expand the static fields so they're
7713      ready to be used somewhere else. <clinit> will be fully expanded
7714      after we processed the constructors. */
7715   first_decl = TYPE_METHODS (current_class);
7716   clinit = maybe_generate_pre_expand_clinit (current_class);
7717
7718   /* Then generate finit$ (if we need to) because constructors will
7719    try to use it.*/
7720   if (TYPE_FINIT_STMT_LIST (current_class))
7721     java_complete_expand_method (generate_finit (current_class));
7722
7723   /* Then generate instinit$ (if we need to) because constructors will
7724      try to use it. */
7725   if (TYPE_II_STMT_LIST (current_class))
7726     java_complete_expand_method (generate_instinit (current_class));
7727
7728   /* Now do the constructors */
7729   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7730     {
7731       int no_body;
7732
7733       if (!DECL_CONSTRUCTOR_P (decl))
7734         continue;
7735
7736       no_body = !DECL_FUNCTION_BODY (decl);
7737       /* Don't generate debug info on line zero when expanding a
7738          generated constructor. */
7739       if (no_body)
7740         restore_line_number_status (1);
7741
7742       java_complete_expand_method (decl);
7743
7744       if (no_body)
7745         restore_line_number_status (0);
7746     }
7747
7748   /* First, do the ordinary methods. */
7749   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7750     {
7751       /* Ctors aren't part of this batch. */
7752       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7753         continue;
7754
7755       /* Skip abstract or native methods -- but do handle native
7756          methods when generating JNI stubs.  */
7757       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7758         {
7759           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7760           continue;
7761         }
7762
7763       if (METHOD_NATIVE (decl))
7764         {
7765           tree body;
7766           current_function_decl = decl;
7767           body = build_jni_stub (decl);
7768           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7769         }
7770
7771       java_complete_expand_method (decl);
7772     }
7773
7774   /* If there is indeed a <clinit>, fully expand it now */
7775   if (clinit)
7776     {
7777       /* Prevent the use of `this' inside <clinit> */
7778       ctxp->explicit_constructor_p = 1;
7779       java_complete_expand_method (clinit);
7780       ctxp->explicit_constructor_p = 0;
7781     }
7782
7783   /* We might have generated a class$ that we now want to expand */
7784   if (TYPE_DOT_CLASS (current_class))
7785     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7786
7787   /* Now verify constructor circularity (stop after the first one we
7788      prove wrong.) */
7789   if (!CLASS_INTERFACE (class_decl))
7790     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7791       if (DECL_CONSTRUCTOR_P (decl)
7792           && verify_constructor_circularity (decl, decl))
7793         break;
7794 }
7795
7796 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7797    safely used in some other methods/constructors.  */
7798
7799 static tree
7800 maybe_generate_pre_expand_clinit (tree class_type)
7801 {
7802   tree current, mdecl;
7803
7804   if (!TYPE_CLINIT_STMT_LIST (class_type))
7805     return NULL_TREE;
7806
7807   /* Go through all static fields and pre expand them */
7808   for (current = TYPE_FIELDS (class_type); current;
7809        current = TREE_CHAIN (current))
7810     if (FIELD_STATIC (current))
7811       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7812
7813   /* Then build the <clinit> method */
7814   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7815                                     clinit_identifier_node, end_params_node);
7816   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7817                        mdecl, NULL_TREE);
7818   start_artificial_method_body (mdecl);
7819
7820   /* We process the list of assignment we produced as the result of
7821      the declaration of initialized static field and add them as
7822      statement to the <clinit> method. */
7823   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7824        current = TREE_CHAIN (current))
7825     {
7826       tree stmt = current;
7827       /* We build the assignment expression that will initialize the
7828          field to its value. There are strict rules on static
7829          initializers (8.5). FIXME */
7830       if (TREE_CODE (stmt) != BLOCK && stmt != empty_stmt_node)
7831         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7832       java_method_add_stmt (mdecl, stmt);
7833     }
7834
7835   end_artificial_method_body (mdecl);
7836
7837   /* Now we want to place <clinit> as the last method (because we need
7838      it at least for interface so that it doesn't interfere with the
7839      dispatch table based lookup. */
7840   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7841     {
7842       current = TREE_CHAIN (TYPE_METHODS (class_type));
7843       TYPE_METHODS (class_type) = current;
7844
7845       while (TREE_CHAIN (current))
7846         current = TREE_CHAIN (current);
7847
7848       TREE_CHAIN (current) = mdecl;
7849       TREE_CHAIN (mdecl) = NULL_TREE;
7850     }
7851
7852   return mdecl;
7853 }
7854
7855 /* Analyzes a method body and look for something that isn't a
7856    MODIFY_EXPR with a constant value.  */
7857
7858 static int
7859 analyze_clinit_body (tree this_class, tree bbody)
7860 {
7861   while (bbody)
7862     switch (TREE_CODE (bbody))
7863       {
7864       case BLOCK:
7865         bbody = BLOCK_EXPR_BODY (bbody);
7866         break;
7867
7868       case EXPR_WITH_FILE_LOCATION:
7869         bbody = EXPR_WFL_NODE (bbody);
7870         break;
7871
7872       case COMPOUND_EXPR:
7873         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
7874           return 1;
7875         bbody = TREE_OPERAND (bbody, 1);
7876         break;
7877
7878       case MODIFY_EXPR:
7879         /* If we're generating to class file and we're dealing with an
7880            array initialization, we return 1 to keep <clinit> */
7881         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
7882             && flag_emit_class_files)
7883           return 1;
7884
7885         /* There are a few cases where we're required to keep
7886            <clinit>:
7887            - If this is an assignment whose operand is not constant,
7888            - If this is an assignment to a non-initialized field,
7889            - If this field is not a member of the current class.
7890         */
7891         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
7892                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
7893                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
7894
7895       default:
7896         return 1;
7897       }
7898   return 0;
7899 }
7900
7901
7902 /* See whether we could get rid of <clinit>. Criteria are: all static
7903    final fields have constant initial values and the body of <clinit>
7904    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
7905
7906 static int
7907 maybe_yank_clinit (tree mdecl)
7908 {
7909   tree type, current;
7910   tree fbody, bbody;
7911
7912   if (!DECL_CLINIT_P (mdecl))
7913     return 0;
7914
7915   /* If the body isn't empty, then we keep <clinit>. Note that if
7916      we're emitting classfiles, this isn't enough not to rule it
7917      out. */
7918   fbody = DECL_FUNCTION_BODY (mdecl);
7919   bbody = BLOCK_EXPR_BODY (fbody);
7920   if (bbody && bbody != error_mark_node)
7921     bbody = BLOCK_EXPR_BODY (bbody);
7922   else
7923     return 0;
7924   if (bbody && ! flag_emit_class_files && bbody != empty_stmt_node)
7925     return 0;
7926
7927   type = DECL_CONTEXT (mdecl);
7928   current = TYPE_FIELDS (type);
7929
7930   for (current = (current ? TREE_CHAIN (current) : current);
7931        current; current = TREE_CHAIN (current))
7932     {
7933       tree f_init;
7934
7935       /* We're not interested in non-static fields.  */
7936       if (!FIELD_STATIC (current))
7937         continue;
7938
7939       /* Nor in fields without initializers. */
7940       f_init = DECL_INITIAL (current);
7941       if (f_init == NULL_TREE)
7942         continue;
7943
7944       /* Anything that isn't String or a basic type is ruled out -- or
7945          if we know how to deal with it (when doing things natively) we
7946          should generated an empty <clinit> so that SUID are computed
7947          correctly. */
7948       if (! JSTRING_TYPE_P (TREE_TYPE (current))
7949           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
7950         return 0;
7951
7952       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
7953         return 0;
7954     }
7955
7956   /* Now we analyze the method body and look for something that
7957      isn't a MODIFY_EXPR */
7958   if (bbody != empty_stmt_node && analyze_clinit_body (type, bbody))
7959     return 0;
7960
7961   /* Get rid of <clinit> in the class' list of methods */
7962   if (TYPE_METHODS (type) == mdecl)
7963     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
7964   else
7965     for (current = TYPE_METHODS (type); current;
7966          current = TREE_CHAIN (current))
7967       if (TREE_CHAIN (current) == mdecl)
7968         {
7969           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
7970           break;
7971         }
7972
7973   return 1;
7974 }
7975
7976 /* Install the argument from MDECL. Suitable to completion and
7977    expansion of mdecl's body.  */
7978
7979 void
7980 start_complete_expand_method (tree mdecl)
7981 {
7982   tree tem;
7983
7984   pushlevel (1);                /* Prepare for a parameter push */
7985   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7986   DECL_ARGUMENTS (mdecl) = tem;
7987
7988   for (; tem; tem = TREE_CHAIN (tem))
7989     {
7990       /* TREE_CHAIN (tem) will change after pushdecl. */
7991       tree next = TREE_CHAIN (tem);
7992       tree type = TREE_TYPE (tem);
7993       if (PROMOTE_PROTOTYPES
7994           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
7995           && INTEGRAL_TYPE_P (type))
7996         type = integer_type_node;
7997       DECL_ARG_TYPE (tem) = type;
7998       layout_decl (tem, 0);
7999       pushdecl (tem);
8000       /* Re-install the next so that the list is kept and the loop
8001          advances. */
8002       TREE_CHAIN (tem) = next;
8003     }
8004   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8005   input_line = DECL_SOURCE_LINE (mdecl);
8006   build_result_decl (mdecl);
8007 }
8008
8009
8010 /* Complete and expand a method.  */
8011
8012 static void
8013 java_complete_expand_method (tree mdecl)
8014 {
8015   tree fbody, block_body, exception_copy;
8016
8017   current_function_decl = mdecl;
8018   /* Fix constructors before expanding them */
8019   if (DECL_CONSTRUCTOR_P (mdecl))
8020     fix_constructors (mdecl);
8021
8022   /* Expand functions that have a body */
8023   if (!DECL_FUNCTION_BODY (mdecl))
8024     return;
8025
8026   fbody = DECL_FUNCTION_BODY (mdecl);
8027   block_body = BLOCK_EXPR_BODY (fbody);
8028   exception_copy = NULL_TREE;
8029
8030   current_function_decl = mdecl;
8031
8032   if (! quiet_flag)
8033     fprintf (stderr, " [%s.",
8034              lang_printable_name (DECL_CONTEXT (mdecl), 0));
8035   announce_function (mdecl);
8036   if (! quiet_flag)
8037     fprintf (stderr, "]");
8038
8039   /* Prepare the function for tree completion */
8040   start_complete_expand_method (mdecl);
8041
8042   /* Install the current this */
8043   current_this = (!METHOD_STATIC (mdecl) ?
8044                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8045
8046   /* Purge the `throws' list of unchecked exceptions (we save a copy
8047      of the list and re-install it later.) */
8048   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8049   purge_unchecked_exceptions (mdecl);
8050
8051   /* Install exceptions thrown with `throws' */
8052   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8053
8054   if (block_body != NULL_TREE)
8055     {
8056       block_body = java_complete_tree (block_body);
8057
8058       /* Before we check initialization, attached all class initialization
8059          variable to the block_body */
8060       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8061                      attach_init_test_initialization_flags, block_body);
8062
8063       if (! flag_emit_xref && ! METHOD_NATIVE (mdecl))
8064         {
8065           check_for_initialization (block_body, mdecl);
8066
8067           /* Go through all the flags marking the initialization of
8068              static variables and see whether they're definitively
8069              assigned, in which case the type is remembered as
8070              definitively initialized in MDECL. */
8071           if (STATIC_CLASS_INIT_OPT_P ())
8072             {
8073               /* Always register the context as properly initialized in
8074                  MDECL. This used with caution helps removing extra
8075                  initialization of self. */
8076               if (METHOD_STATIC (mdecl))
8077                 {
8078                   *(htab_find_slot
8079                     (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8080                      DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8081                 }
8082             }
8083         }
8084       ctxp->explicit_constructor_p = 0;
8085     }
8086
8087   BLOCK_EXPR_BODY (fbody) = block_body;
8088
8089   /* If we saw a return but couldn't evaluate it properly, we'll have
8090      an error_mark_node here. */
8091   if (block_body != error_mark_node
8092       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8093       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE
8094       && !flag_emit_xref)
8095     missing_return_error (current_function_decl);
8096
8097   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8098   maybe_yank_clinit (mdecl);
8099
8100   /* Pop the current level, with special measures if we found errors. */
8101   if (java_error_count)
8102     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8103   poplevel (1, 0, 1);
8104
8105   /* Pop the exceptions and sanity check */
8106   POP_EXCEPTIONS();
8107   if (currently_caught_type_list)
8108     abort ();
8109
8110   /* Restore the copy of the list of exceptions if emitting xrefs. */
8111   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8112 }
8113
8114 /* For with each class for which there's code to generate. */
8115
8116 static void
8117 java_expand_method_bodies (tree class)
8118 {
8119   tree decl;
8120   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8121     {
8122       tree block;
8123       tree body;
8124
8125       if (! DECL_FUNCTION_BODY (decl))
8126         continue;
8127
8128       current_function_decl = decl;
8129
8130       block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8131
8132       if (TREE_CODE (block) != BLOCK)
8133         abort ();
8134
8135       /* Save the function body for inlining.  */
8136       DECL_SAVED_TREE (decl) = block;
8137
8138       body = BLOCK_EXPR_BODY (block);
8139
8140       if (TREE_TYPE (body) == NULL_TREE)
8141         abort ();
8142
8143       /* It's time to assign the variable flagging static class
8144          initialization based on which classes invoked static methods
8145          are definitely initializing. This should be flagged. */
8146       if (STATIC_CLASS_INIT_OPT_P ())
8147         {
8148           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8149           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8150             {
8151               /* Executed for each statement calling a static function.
8152                  LIST is a TREE_LIST whose PURPOSE is the called function
8153                  and VALUE is a compound whose second operand can be patched
8154                  with static class initialization flag assignments.  */
8155
8156               tree called_method = TREE_PURPOSE (list);
8157               tree compound = TREE_VALUE (list);
8158               tree assignment_compound_list
8159                 = build_tree_list (called_method, NULL);
8160
8161               /* For each class definitely initialized in
8162                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8163                  assignment to the class initialization flag. */
8164               htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8165                              emit_test_initialization,
8166                              assignment_compound_list);
8167
8168               if (TREE_VALUE (assignment_compound_list))
8169                 TREE_OPERAND (compound, 1)
8170                   = TREE_VALUE (assignment_compound_list);
8171             }
8172         }
8173
8174       /* Prepend class initialization to static methods.  */
8175       if (METHOD_STATIC (decl) && ! METHOD_PRIVATE (decl)
8176           && ! flag_emit_class_files
8177           && ! DECL_CLINIT_P (decl)
8178           && ! CLASS_INTERFACE (TYPE_NAME (class)))
8179         {
8180           tree init = build (CALL_EXPR, void_type_node,
8181                              build_address_of (soft_initclass_node),
8182                              build_tree_list (NULL_TREE,
8183                                               build_class_ref (class)),
8184                              NULL_TREE);
8185           TREE_SIDE_EFFECTS (init) = 1;
8186           body = build (COMPOUND_EXPR, TREE_TYPE (body), init, body);
8187           BLOCK_EXPR_BODY (block) = body;
8188         }
8189
8190       /* Wrap synchronized method bodies in a monitorenter
8191          plus monitorexit cleanup.  */
8192       if (METHOD_SYNCHRONIZED (decl) && ! flag_emit_class_files)
8193         {
8194           tree enter, exit, lock;
8195           if (METHOD_STATIC (decl))
8196             lock = build_class_ref (class);
8197           else
8198             lock = DECL_ARGUMENTS (decl);
8199           BUILD_MONITOR_ENTER (enter, lock);
8200           BUILD_MONITOR_EXIT (exit, lock);
8201
8202           body = build (COMPOUND_EXPR, void_type_node,
8203                         enter,
8204                         build (TRY_FINALLY_EXPR, void_type_node, body, exit));
8205           BLOCK_EXPR_BODY (block) = body;
8206         }
8207
8208       /* Expand the the function body.  */
8209       source_end_java_method ();
8210     }
8211 }
8212
8213 \f
8214
8215 /* This section of the code deals with accessing enclosing context
8216    fields either directly by using the relevant access to this$<n> or
8217    by invoking an access method crafted for that purpose.  */
8218
8219 /* Build the necessary access from an inner class to an outer
8220    class. This routine could be optimized to cache previous result
8221    (decl, current_class and returned access).  When an access method
8222    needs to be generated, it always takes the form of a read. It might
8223    be later turned into a write by calling outer_field_access_fix.  */
8224
8225 static tree
8226 build_outer_field_access (tree id, tree decl)
8227 {
8228   tree access = NULL_TREE;
8229   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8230   tree decl_ctx = DECL_CONTEXT (decl);
8231
8232   /* If the immediate enclosing context of the current class is the
8233      field decl's class or inherits from it; build the access as
8234      `this$<n>.<field>'. Note that we will break the `private' barrier
8235      if we're not emitting bytecodes. */
8236   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8237       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8238     {
8239       tree thisn = build_current_thisn (current_class);
8240       access = make_qualified_primary (build_wfl_node (thisn),
8241                                        id, EXPR_WFL_LINECOL (id));
8242     }
8243   /* Otherwise, generate access methods to outer this and access the
8244      field (either using an access method or by direct access.) */
8245   else
8246     {
8247       int lc = EXPR_WFL_LINECOL (id);
8248
8249       /* Now we chain the required number of calls to the access$0 to
8250          get a hold to the enclosing instance we need, and then we
8251          build the field access. */
8252       access = build_access_to_thisn (current_class, decl_ctx, lc);
8253
8254       /* If the field is private and we're generating bytecode, then
8255          we generate an access method */
8256       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8257         {
8258           tree name = build_outer_field_access_methods (decl);
8259           access = build_outer_field_access_expr (lc, decl_ctx,
8260                                                   name, access, NULL_TREE);
8261         }
8262       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8263          Once again we break the `private' access rule from a foreign
8264          class. */
8265       else
8266         access = make_qualified_primary (access, id, lc);
8267     }
8268   return resolve_expression_name (access, NULL);
8269 }
8270
8271 /* Return a nonzero value if NODE describes an outer field inner
8272    access.  */
8273
8274 static int
8275 outer_field_access_p (tree type, tree decl)
8276 {
8277   if (!INNER_CLASS_TYPE_P (type)
8278       || TREE_CODE (decl) != FIELD_DECL
8279       || DECL_CONTEXT (decl) == type)
8280     return 0;
8281
8282   /* If the inner class extends the declaration context of the field
8283      we're trying to access, then this isn't an outer field access */
8284   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8285     return 0;
8286
8287   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8288        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8289     {
8290       if (type == DECL_CONTEXT (decl))
8291         return 1;
8292
8293       if (!DECL_CONTEXT (TYPE_NAME (type)))
8294         {
8295           /* Before we give up, see whether the field is inherited from
8296              the enclosing context we're considering. */
8297           if (inherits_from_p (type, DECL_CONTEXT (decl)))
8298             return 1;
8299           break;
8300         }
8301     }
8302
8303   return 0;
8304 }
8305
8306 /* Return a nonzero value if NODE represents an outer field inner
8307    access that was been already expanded. As a side effect, it returns
8308    the name of the field being accessed and the argument passed to the
8309    access function, suitable for a regeneration of the access method
8310    call if necessary. */
8311
8312 static int
8313 outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8314                                tree *arg)
8315 {
8316   int identified = 0;
8317
8318   if (TREE_CODE (node) != CALL_EXPR)
8319     return 0;
8320
8321   /* Well, gcj generates slightly different tree nodes when compiling
8322      to native or bytecodes. It's the case for function calls. */
8323
8324   if (flag_emit_class_files
8325       && TREE_CODE (node) == CALL_EXPR
8326       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8327     identified = 1;
8328   else if (!flag_emit_class_files)
8329     {
8330       node = TREE_OPERAND (node, 0);
8331
8332       if (node && TREE_OPERAND (node, 0)
8333           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8334         {
8335           node = TREE_OPERAND (node, 0);
8336           if (TREE_OPERAND (node, 0)
8337               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8338               && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8339                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8340             identified = 1;
8341         }
8342     }
8343
8344   if (identified && name && arg_type && arg)
8345     {
8346       tree argument = TREE_OPERAND (node, 1);
8347       *name = DECL_NAME (TREE_OPERAND (node, 0));
8348       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8349       *arg = TREE_VALUE (argument);
8350     }
8351   return identified;
8352 }
8353
8354 /* Detect in NODE an outer field read access from an inner class and
8355    transform it into a write with RHS as an argument. This function is
8356    called from the java_complete_lhs when an assignment to a LHS can
8357    be identified. */
8358
8359 static tree
8360 outer_field_access_fix (tree wfl, tree node, tree rhs)
8361 {
8362   tree name, arg_type, arg;
8363
8364   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8365     {
8366       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8367                                             arg_type, name, arg, rhs);
8368       return java_complete_tree (node);
8369     }
8370   return NULL_TREE;
8371 }
8372
8373 /* Construct the expression that calls an access method:
8374      <type>.access$<n>(<arg1> [, <arg2>]);
8375
8376    ARG2 can be NULL and will be omitted in that case. It will denote a
8377    read access.  */
8378
8379 static tree
8380 build_outer_field_access_expr (int lc, tree type, tree access_method_name,
8381                                tree arg1, tree arg2)
8382 {
8383   tree args, cn, access;
8384
8385   args = arg1 ? arg1 :
8386     build_wfl_node (build_current_thisn (current_class));
8387   args = build_tree_list (NULL_TREE, args);
8388
8389   if (arg2)
8390     args = tree_cons (NULL_TREE, arg2, args);
8391
8392   access = build_method_invocation (build_wfl_node (access_method_name), args);
8393   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8394   return make_qualified_primary (cn, access, lc);
8395 }
8396
8397 static tree
8398 build_new_access_id (void)
8399 {
8400   static int access_n_counter = 1;
8401   char buffer [128];
8402
8403   sprintf (buffer, "access$%d", access_n_counter++);
8404   return get_identifier (buffer);
8405 }
8406
8407 /* Create the static access functions for the outer field DECL. We define a
8408    read:
8409      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8410        return inst$.field;
8411      }
8412    and a write access:
8413      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8414                                      TREE_TYPE (<field>) value$) {
8415        return inst$.field = value$;
8416      }
8417    We should have a usage flags on the DECL so we can lazily turn the ones
8418    we're using for code generation. FIXME.
8419 */
8420
8421 static tree
8422 build_outer_field_access_methods (tree decl)
8423 {
8424   tree id, args, stmt, mdecl;
8425
8426   if (FIELD_INNER_ACCESS_P (decl))
8427     return FIELD_INNER_ACCESS (decl);
8428
8429   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8430
8431   /* Create the identifier and a function named after it. */
8432   id = build_new_access_id ();
8433
8434   /* The identifier is marked as bearing the name of a generated write
8435      access function for outer field accessed from inner classes. */
8436   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8437
8438   /* Create the read access */
8439   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8440   TREE_CHAIN (args) = end_params_node;
8441   stmt = make_qualified_primary (build_wfl_node (inst_id),
8442                                  build_wfl_node (DECL_NAME (decl)), 0);
8443   stmt = build_return (0, stmt);
8444   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8445                                            TREE_TYPE (decl), id, args, stmt);
8446   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8447
8448   /* Create the write access method. No write access for final variable */
8449   if (!FIELD_FINAL (decl))
8450     {
8451       args = build_tree_list (inst_id,
8452                               build_pointer_type (DECL_CONTEXT (decl)));
8453       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8454       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8455       stmt = make_qualified_primary (build_wfl_node (inst_id),
8456                                      build_wfl_node (DECL_NAME (decl)), 0);
8457       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8458                                                 build_wfl_node (wpv_id)));
8459       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8460                                                TREE_TYPE (decl), id,
8461                                                args, stmt);
8462     }
8463   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8464
8465   /* Return the access name */
8466   return FIELD_INNER_ACCESS (decl) = id;
8467 }
8468
8469 /* Build an field access method NAME.  */
8470
8471 static tree
8472 build_outer_field_access_method (tree class, tree type, tree name,
8473                                  tree args, tree body)
8474 {
8475   tree saved_current_function_decl, mdecl;
8476
8477   /* Create the method */
8478   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8479   fix_method_argument_names (args, mdecl);
8480   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8481
8482   /* Attach the method body. */
8483   saved_current_function_decl = current_function_decl;
8484   start_artificial_method_body (mdecl);
8485   java_method_add_stmt (mdecl, body);
8486   end_artificial_method_body (mdecl);
8487   current_function_decl = saved_current_function_decl;
8488
8489   return mdecl;
8490 }
8491
8492 \f
8493 /* This section deals with building access function necessary for
8494    certain kinds of method invocation from inner classes.  */
8495
8496 static tree
8497 build_outer_method_access_method (tree decl)
8498 {
8499   tree saved_current_function_decl, mdecl;
8500   tree args = NULL_TREE, call_args = NULL_TREE;
8501   tree carg, id, body, class;
8502   char buffer [80];
8503   int parm_id_count = 0;
8504
8505   /* Test this abort with an access to a private field */
8506   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8507     abort ();
8508
8509   /* Check the cache first */
8510   if (DECL_FUNCTION_INNER_ACCESS (decl))
8511     return DECL_FUNCTION_INNER_ACCESS (decl);
8512
8513   class = DECL_CONTEXT (decl);
8514
8515   /* Obtain an access identifier and mark it */
8516   id = build_new_access_id ();
8517   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8518
8519   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8520   /* Create the arguments, as much as the original */
8521   for (; carg && carg != end_params_node;
8522        carg = TREE_CHAIN (carg))
8523     {
8524       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8525       args = chainon (args, build_tree_list (get_identifier (buffer),
8526                                              TREE_VALUE (carg)));
8527     }
8528   args = chainon (args, end_params_node);
8529
8530   /* Create the method */
8531   mdecl = create_artificial_method (class, ACC_STATIC,
8532                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8533   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8534   /* There is a potential bug here. We should be able to use
8535      fix_method_argument_names, but then arg names get mixed up and
8536      eventually a constructor will have its this$0 altered and the
8537      outer context won't be assignment properly. The testcase is
8538      stub.java FIXME */
8539   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8540
8541   /* Attach the method body. */
8542   saved_current_function_decl = current_function_decl;
8543   start_artificial_method_body (mdecl);
8544
8545   /* The actual method invocation uses the same args. When invoking a
8546      static methods that way, we don't want to skip the first
8547      argument. */
8548   carg = args;
8549   if (!METHOD_STATIC (decl))
8550     carg = TREE_CHAIN (carg);
8551   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8552     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8553                            call_args);
8554
8555   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8556                                   call_args);
8557   if (!METHOD_STATIC (decl))
8558     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8559                                    body, 0);
8560   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8561     body = build_return (0, body);
8562   java_method_add_stmt (mdecl,body);
8563   end_artificial_method_body (mdecl);
8564   current_function_decl = saved_current_function_decl;
8565
8566   /* Back tag the access function so it know what it accesses */
8567   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8568
8569   /* Tag the current method so it knows it has an access generated */
8570   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8571 }
8572
8573 \f
8574 /* This section of the code deals with building expressions to access
8575    the enclosing instance of an inner class. The enclosing instance is
8576    kept in a generated field called this$<n>, with <n> being the
8577    inner class nesting level (starting from 0.)  */
8578
8579 /* Build an access to a given this$<n>, always chaining access call to
8580    others. Access methods to this$<n> are build on the fly if
8581    necessary. This CAN'T be used to solely access this$<n-1> from
8582    this$<n> (which alway yield to special cases and optimization, see
8583    for example build_outer_field_access).  */
8584
8585 static tree
8586 build_access_to_thisn (tree from, tree to, int lc)
8587 {
8588   tree access = NULL_TREE;
8589
8590   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8591     {
8592       if (!access)
8593         {
8594           access = build_current_thisn (from);
8595           access = build_wfl_node (access);
8596         }
8597       else
8598         {
8599           tree access0_wfl, cn;
8600
8601           maybe_build_thisn_access_method (from);
8602           access0_wfl = build_wfl_node (access0_identifier_node);
8603           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8604           EXPR_WFL_LINECOL (access0_wfl) = lc;
8605           access = build_tree_list (NULL_TREE, access);
8606           access = build_method_invocation (access0_wfl, access);
8607           access = make_qualified_primary (cn, access, lc);
8608         }
8609
8610       /* If FROM isn't an inner class, that's fine, we've done enough.
8611          What we're looking for can be accessed from there.  */
8612       from = DECL_CONTEXT (TYPE_NAME (from));
8613       if (!from)
8614         break;
8615       from = TREE_TYPE (from);
8616     }
8617   return access;
8618 }
8619
8620 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8621    is returned if nothing needs to be generated. Otherwise, the method
8622    generated and a method decl is returned.
8623
8624    NOTE: These generated methods should be declared in a class file
8625    attribute so that they can't be referred to directly.  */
8626
8627 static tree
8628 maybe_build_thisn_access_method (tree type)
8629 {
8630   tree mdecl, args, stmt, rtype;
8631   tree saved_current_function_decl;
8632
8633   /* If TYPE is a top-level class, no access method is required.
8634      If there already is such an access method, bail out. */
8635   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8636     return NULL_TREE;
8637
8638   /* We generate the method. The method looks like:
8639      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8640   */
8641   args = build_tree_list (inst_id, build_pointer_type (type));
8642   TREE_CHAIN (args) = end_params_node;
8643   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8644   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8645                                     access0_identifier_node, args);
8646   fix_method_argument_names (args, mdecl);
8647   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8648   stmt = build_current_thisn (type);
8649   stmt = make_qualified_primary (build_wfl_node (inst_id),
8650                                  build_wfl_node (stmt), 0);
8651   stmt = build_return (0, stmt);
8652
8653   saved_current_function_decl = current_function_decl;
8654   start_artificial_method_body (mdecl);
8655   java_method_add_stmt (mdecl, stmt);
8656   end_artificial_method_body (mdecl);
8657   current_function_decl = saved_current_function_decl;
8658
8659   CLASS_ACCESS0_GENERATED_P (type) = 1;
8660
8661   return mdecl;
8662 }
8663
8664 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8665    the first level of innerclassing. this$1 for the next one, etc...
8666    This function can be invoked with TYPE to NULL, available and then
8667    has to count the parser context.  */
8668
8669 static GTY(()) tree saved_thisn;
8670 static GTY(()) tree saved_type;
8671
8672 static tree
8673 build_current_thisn (tree type)
8674 {
8675   static int saved_i = -1;
8676   static int saved_type_i = 0;
8677   tree decl;
8678   char buffer [24];
8679   int i = 0;
8680
8681   if (type)
8682     {
8683       if (type == saved_type)
8684         i = saved_type_i;
8685       else
8686         {
8687           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8688                decl; decl = DECL_CONTEXT (decl), i++)
8689             ;
8690
8691           saved_type = type;
8692           saved_type_i = i;
8693         }
8694     }
8695   else
8696     i = list_length (GET_CPC_LIST ())-2;
8697
8698   if (i == saved_i)
8699     return saved_thisn;
8700
8701   sprintf (buffer, "this$%d", i);
8702   saved_i = i;
8703   saved_thisn = get_identifier (buffer);
8704   return saved_thisn;
8705 }
8706
8707 /* Return the assignment to the hidden enclosing context `this$<n>'
8708    by the second incoming parameter to the innerclass constructor. The
8709    form used is `this.this$<n> = this$<n>;'.  */
8710
8711 static tree
8712 build_thisn_assign (void)
8713 {
8714   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8715     {
8716       tree thisn = build_current_thisn (current_class);
8717       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8718                                          build_wfl_node (thisn), 0);
8719       tree rhs = build_wfl_node (thisn);
8720       EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8721       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8722     }
8723   return NULL_TREE;
8724 }
8725
8726 \f
8727 /* Building the synthetic `class$' used to implement the `.class' 1.1
8728    extension for non primitive types. This method looks like:
8729
8730     static Class class$(String type) throws NoClassDefFoundError
8731     {
8732       try {return (java.lang.Class.forName (String));}
8733       catch (ClassNotFoundException e) {
8734         throw new NoClassDefFoundError(e.getMessage());}
8735     } */
8736
8737 static GTY(()) tree get_message_wfl;
8738 static GTY(()) tree type_parm_wfl;
8739
8740 static tree
8741 build_dot_class_method (tree class)
8742 {
8743 #define BWF(S) build_wfl_node (get_identifier ((S)))
8744 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8745   tree args, tmp, saved_current_function_decl, mdecl, qual_name;
8746   tree stmt, throw_stmt;
8747
8748   if (!get_message_wfl)
8749     {
8750       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8751       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8752     }
8753
8754   /* Build the arguments */
8755   args = build_tree_list (get_identifier ("type$"),
8756                           build_pointer_type (string_type_node));
8757   TREE_CHAIN (args) = end_params_node;
8758
8759   /* Build the qualified name java.lang.Class.forName */
8760   tmp = MQN (MQN (MQN (BWF ("java"),
8761                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8762
8763   /* Create the "class$" function */
8764   mdecl = create_artificial_method (class, ACC_STATIC,
8765                                     build_pointer_type (class_type_node),
8766                                     classdollar_identifier_node, args);
8767   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8768                    BWF ("NoClassDefFoundError"));
8769   DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE, qual_name);
8770   register_incomplete_type (JDEP_EXCEPTION, qual_name, NULL_TREE, NULL_TREE);
8771   JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
8772     &TREE_VALUE (DECL_FUNCTION_THROWS (mdecl));
8773
8774   /* We start by building the try block. We need to build:
8775        return (java.lang.Class.forName (type)); */
8776   stmt = build_method_invocation (tmp,
8777                                   build_tree_list (NULL_TREE, type_parm_wfl));
8778   stmt = build_return (0, stmt);
8779
8780   /* Now onto the catch block. We start by building the expression
8781      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8782   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8783                                     get_message_wfl, 0);
8784   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8785
8786   /* Build new NoClassDefFoundError (_.getMessage) */
8787   throw_stmt = build_new_invocation
8788     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8789      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8790
8791   /* Build the throw, (it's too early to use BUILD_THROW) */
8792   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8793
8794   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8795   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8796                    BWF ("ClassNotFoundException"));
8797   stmt = encapsulate_with_try_catch (0, qual_name, stmt, throw_stmt);
8798
8799   fix_method_argument_names (args, mdecl);
8800   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8801   saved_current_function_decl = current_function_decl;
8802   start_artificial_method_body (mdecl);
8803   java_method_add_stmt (mdecl, stmt);
8804   end_artificial_method_body (mdecl);
8805   current_function_decl = saved_current_function_decl;
8806   TYPE_DOT_CLASS (class) = mdecl;
8807
8808   return mdecl;
8809 }
8810
8811 static tree
8812 build_dot_class_method_invocation (tree this_class, tree type)
8813 {
8814   tree dot_class_method = TYPE_DOT_CLASS (this_class);
8815   tree sig_id, s, t;
8816
8817   if (TYPE_ARRAY_P (type))
8818     sig_id = build_java_signature (type);
8819   else
8820     sig_id = DECL_NAME (TYPE_NAME (type));
8821
8822   /* Ensure that the proper name separator is used */
8823   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8824                                IDENTIFIER_LENGTH (sig_id));
8825
8826   s = build_string (IDENTIFIER_LENGTH (sig_id),
8827                     IDENTIFIER_POINTER (sig_id));
8828   t = build_method_invocation (build_wfl_node (DECL_NAME (dot_class_method)),
8829                                build_tree_list (NULL_TREE, s));
8830   if (DECL_CONTEXT (dot_class_method) != this_class)
8831     {
8832       tree class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (dot_class_method)));
8833       t = make_qualified_primary (build_wfl_node (class_name), t, 0);
8834     }
8835   return t;
8836 }
8837
8838 /* This section of the code deals with constructor.  */
8839
8840 /* Craft a body for default constructor. Patch existing constructor
8841    bodies with call to super() and field initialization statements if
8842    necessary.  */
8843
8844 static void
8845 fix_constructors (tree mdecl)
8846 {
8847   tree iii;                     /* Instance Initializer Invocation */
8848   tree body = DECL_FUNCTION_BODY (mdecl);
8849   tree thisn_assign, compound = NULL_TREE;
8850   tree class_type = DECL_CONTEXT (mdecl);
8851
8852   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8853     return;
8854   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8855
8856   if (!body)
8857     {
8858       /* It is an error for the compiler to generate a default
8859          constructor if the superclass doesn't have a constructor that
8860          takes no argument, or the same args for an anonymous class */
8861       if (verify_constructor_super (mdecl))
8862         {
8863           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8864           tree save = DECL_NAME (mdecl);
8865           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8866           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8867           parse_error_context
8868             (lookup_cl (TYPE_NAME (class_type)),
8869              "No constructor matching `%s' found in class `%s'",
8870              lang_printable_name (mdecl, 0), n);
8871           DECL_NAME (mdecl) = save;
8872         }
8873
8874       /* The constructor body must be crafted by hand. It's the
8875          constructor we defined when we realize we didn't have the
8876          CLASSNAME() constructor */
8877       start_artificial_method_body (mdecl);
8878
8879       /* Insert an assignment to the this$<n> hidden field, if
8880          necessary */
8881       if ((thisn_assign = build_thisn_assign ()))
8882         java_method_add_stmt (mdecl, thisn_assign);
8883
8884       /* We don't generate a super constructor invocation if we're
8885          compiling java.lang.Object. build_super_invocation takes care
8886          of that. */
8887       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8888
8889       /* FIXME */
8890       if ((iii = build_instinit_invocation (class_type)))
8891         java_method_add_stmt (mdecl, iii);
8892
8893       end_artificial_method_body (mdecl);
8894     }
8895   /* Search for an explicit constructor invocation */
8896   else
8897     {
8898       int found = 0;
8899       int invokes_this = 0;
8900       tree found_call = NULL_TREE;
8901       tree main_block = BLOCK_EXPR_BODY (body);
8902
8903       while (body)
8904         switch (TREE_CODE (body))
8905           {
8906           case CALL_EXPR:
8907             found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
8908             if (CALL_THIS_CONSTRUCTOR_P (body))
8909               invokes_this = 1;
8910             body = NULL_TREE;
8911             break;
8912           case COMPOUND_EXPR:
8913           case EXPR_WITH_FILE_LOCATION:
8914             found_call = body;
8915             body = TREE_OPERAND (body, 0);
8916             break;
8917           case BLOCK:
8918             found_call = body;
8919             body = BLOCK_EXPR_BODY (body);
8920             break;
8921           default:
8922             found = 0;
8923             body = NULL_TREE;
8924           }
8925
8926       /* Generate the assignment to this$<n>, if necessary */
8927       if ((thisn_assign = build_thisn_assign ()))
8928         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
8929
8930       /* The constructor is missing an invocation of super() */
8931       if (!found)
8932         compound = add_stmt_to_compound (compound, NULL_TREE,
8933                                          build_super_invocation (mdecl));
8934       /* Explicit super() invocation should take place before the
8935          instance initializer blocks. */
8936       else
8937         {
8938           compound = add_stmt_to_compound (compound, NULL_TREE,
8939                                            TREE_OPERAND (found_call, 0));
8940           TREE_OPERAND (found_call, 0) = empty_stmt_node;
8941         }
8942
8943       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
8944
8945       /* Insert the instance initializer block right after. */
8946       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
8947         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
8948
8949       /* Fix the constructor main block if we're adding extra stmts */
8950       if (compound)
8951         {
8952           compound = add_stmt_to_compound (compound, NULL_TREE,
8953                                            BLOCK_EXPR_BODY (main_block));
8954           BLOCK_EXPR_BODY (main_block) = compound;
8955         }
8956     }
8957 }
8958
8959 /* Browse constructors in the super class, searching for a constructor
8960    that doesn't take any argument. Return 0 if one is found, 1
8961    otherwise.  If the current class is an anonymous inner class, look
8962    for something that has the same signature. */
8963
8964 static int
8965 verify_constructor_super (tree mdecl)
8966 {
8967   tree class = CLASSTYPE_SUPER (current_class);
8968   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
8969   tree sdecl;
8970
8971   if (!class)
8972     return 0;
8973
8974   if (ANONYMOUS_CLASS_P (current_class))
8975     {
8976       tree mdecl_arg_type;
8977       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
8978       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
8979         if (DECL_CONSTRUCTOR_P (sdecl))
8980           {
8981             tree m_arg_type;
8982             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
8983             if (super_inner)
8984               arg_type = TREE_CHAIN (arg_type);
8985             for (m_arg_type = mdecl_arg_type;
8986                  (arg_type != end_params_node
8987                   && m_arg_type != end_params_node);
8988                  arg_type = TREE_CHAIN (arg_type),
8989                    m_arg_type = TREE_CHAIN (m_arg_type))
8990               if (!valid_method_invocation_conversion_p
8991                      (TREE_VALUE (arg_type),
8992                       TREE_VALUE (m_arg_type)))
8993                 break;
8994
8995             if (arg_type == end_params_node && m_arg_type == end_params_node)
8996               return 0;
8997           }
8998     }
8999   else
9000     {
9001       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
9002         {
9003           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
9004           if (super_inner)
9005             arg = TREE_CHAIN (arg);
9006           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
9007             return 0;
9008         }
9009     }
9010   return 1;
9011 }
9012
9013 /* Generate code for all context remembered for code generation.  */
9014
9015 static GTY(()) tree reversed_class_list;
9016 void
9017 java_expand_classes (void)
9018 {
9019   int save_error_count = 0;
9020   static struct parser_ctxt *cur_ctxp = NULL;
9021
9022   java_parse_abort_on_error ();
9023   if (!(ctxp = ctxp_for_generation))
9024     return;
9025   java_layout_classes ();
9026   java_parse_abort_on_error ();
9027
9028   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9029     {
9030       tree current;
9031       for (current = cur_ctxp->class_list;
9032            current;
9033            current = TREE_CHAIN (current))
9034         gen_indirect_dispatch_tables (TREE_TYPE (current));
9035     }
9036
9037   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9038     {
9039       ctxp = cur_ctxp;
9040       input_filename = ctxp->filename;
9041       lang_init_source (2);            /* Error msgs have method prototypes */
9042       java_complete_expand_classes (); /* Complete and expand classes */
9043       java_parse_abort_on_error ();
9044     }
9045   input_filename = main_input_filename;
9046
9047   /* Find anonymous classes and expand their constructor. This extra pass is
9048      necessary because the constructor itself is only generated when the
9049      method in which it is defined is expanded. */
9050   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9051     {
9052       tree current;
9053       ctxp = cur_ctxp;
9054       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9055         {
9056           output_class = current_class = TREE_TYPE (current);
9057           if (ANONYMOUS_CLASS_P (current_class))
9058             {
9059               tree d;
9060               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9061                 {
9062                   if (DECL_CONSTRUCTOR_P (d))
9063                     {
9064                       restore_line_number_status (1);
9065                       java_complete_expand_method (d);
9066                       restore_line_number_status (0);
9067                       break;    /* There is only one constructor. */
9068                     }
9069                 }
9070             }
9071         }
9072     }
9073
9074   /* Expanding the constructors of anonymous classes generates access
9075      methods.  Scan all the methods looking for null DECL_RESULTs --
9076      this will be the case if a method hasn't been expanded.  */
9077   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9078     {
9079       tree current;
9080       ctxp = cur_ctxp;
9081       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9082         {
9083           tree d;
9084           output_class = current_class = TREE_TYPE (current);
9085           for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9086             {
9087               if (DECL_RESULT (d) == NULL_TREE)
9088                 {
9089                   restore_line_number_status (1);
9090                   java_complete_expand_method (d);
9091                   restore_line_number_status (0);
9092                 }
9093             }
9094         }
9095     }
9096
9097   /* ???  Instead of all this we could iterate around the list of
9098      classes until there were no more un-expanded methods.  It would
9099      take a little longer -- one pass over the whole list of methods
9100      -- but it would be simpler.  Like this:  */
9101 #if 0
9102     {
9103       int something_changed;
9104
9105       do
9106         {
9107           something_changed = 0;
9108           for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9109             {
9110               tree current;
9111               ctxp = cur_ctxp;
9112               for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9113                 {
9114                   tree d;
9115                   output_class = current_class = TREE_TYPE (current);
9116                   for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9117                     {
9118                       if (DECL_RESULT (d) == NULL_TREE)
9119                         {
9120                           something_changed = 1;
9121                           restore_line_number_status (1);
9122                           java_complete_expand_method (d);
9123                           restore_line_number_status (0);
9124                         }
9125                     }
9126                 }
9127             }
9128         }
9129       while (something_changed);
9130     }
9131 #endif
9132
9133   /* If we've found error at that stage, don't try to generate
9134      anything, unless we're emitting xrefs or checking the syntax only
9135      (but not using -fsyntax-only for the purpose of generating
9136      bytecode. */
9137   if (java_error_count && !flag_emit_xref
9138       && (!flag_syntax_only && !flag_emit_class_files))
9139     return;
9140
9141   /* Now things are stable, go for generation of the class data. */
9142
9143   /* We pessimistically marked all methods and fields external until
9144      we knew what set of classes we were planning to compile.  Now mark
9145      those that will be generated locally as not external.  */
9146   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9147     {
9148       tree current;
9149       ctxp = cur_ctxp;
9150       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9151         java_mark_class_local (TREE_TYPE (current));
9152     }
9153
9154   /* Compile the classes.  */
9155   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9156     {
9157       tree current;
9158       reversed_class_list = NULL;
9159
9160       ctxp = cur_ctxp;
9161
9162       /* We write out the classes in reverse order.  This ensures that
9163          inner classes are written before their containing classes,
9164          which is important for parallel builds.  Otherwise, the
9165          class file for the outer class may be found, but the class
9166          file for the inner class may not be present.  In that
9167          situation, the compiler cannot fall back to the original
9168          source, having already read the outer class, so we must
9169          prevent that situation.  */
9170       for (current = ctxp->class_list;
9171            current;
9172            current = TREE_CHAIN (current))
9173         reversed_class_list
9174           = tree_cons (NULL_TREE, current, reversed_class_list);
9175
9176       for (current = reversed_class_list;
9177            current;
9178            current = TREE_CHAIN (current))
9179         {
9180           output_class = current_class = TREE_TYPE (TREE_VALUE (current));
9181           if (flag_emit_class_files)
9182             write_classfile (current_class);
9183           if (flag_emit_xref)
9184             expand_xref (current_class);
9185           else if (! flag_syntax_only)
9186             java_expand_method_bodies (current_class);
9187         }
9188     }
9189 }
9190
9191 void
9192 java_finish_classes (void)
9193 {
9194   static struct parser_ctxt *cur_ctxp = NULL;
9195   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9196     {
9197       tree current;
9198       ctxp = cur_ctxp;
9199       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9200         {
9201           output_class = current_class = TREE_TYPE (current);
9202           finish_class ();
9203         }
9204     }
9205 }
9206
9207 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9208    a tree list node containing RIGHT. Fore coming RIGHTs will be
9209    chained to this hook. LOCATION contains the location of the
9210    separating `.' operator.  */
9211
9212 static tree
9213 make_qualified_primary (tree primary, tree right, int location)
9214 {
9215   tree wfl;
9216
9217   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9218     wfl = build_wfl_wrap (primary, location);
9219   else
9220     {
9221       wfl = primary;
9222       /* If wfl wasn't qualified, we build a first anchor */
9223       if (!EXPR_WFL_QUALIFICATION (wfl))
9224         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9225     }
9226
9227   /* And chain them */
9228   EXPR_WFL_LINECOL (right) = location;
9229   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9230   PRIMARY_P (wfl) =  1;
9231   return wfl;
9232 }
9233
9234 /* Simple merge of two name separated by a `.' */
9235
9236 static tree
9237 merge_qualified_name (tree left, tree right)
9238 {
9239   tree node;
9240   if (!left && !right)
9241     return NULL_TREE;
9242
9243   if (!left)
9244     return right;
9245
9246   if (!right)
9247     return left;
9248
9249   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9250                 IDENTIFIER_LENGTH (left));
9251   obstack_1grow (&temporary_obstack, '.');
9252   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9253                  IDENTIFIER_LENGTH (right));
9254   node =  get_identifier (obstack_base (&temporary_obstack));
9255   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9256   QUALIFIED_P (node) = 1;
9257   return node;
9258 }
9259
9260 /* Merge the two parts of a qualified name into LEFT.  Set the
9261    location information of the resulting node to LOCATION, usually
9262    inherited from the location information of the `.' operator. */
9263
9264 static tree
9265 make_qualified_name (tree left, tree right, int location)
9266 {
9267 #ifdef USE_COMPONENT_REF
9268   tree node = build (COMPONENT_REF, NULL_TREE, left, right);
9269   EXPR_WFL_LINECOL (node) = location;
9270   return node;
9271 #else
9272   tree left_id = EXPR_WFL_NODE (left);
9273   tree right_id = EXPR_WFL_NODE (right);
9274   tree wfl, merge;
9275
9276   merge = merge_qualified_name (left_id, right_id);
9277
9278   /* Left wasn't qualified and is now qualified */
9279   if (!QUALIFIED_P (left_id))
9280     {
9281       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9282       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9283       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9284     }
9285
9286   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9287   EXPR_WFL_LINECOL (wfl) = location;
9288   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9289
9290   EXPR_WFL_NODE (left) = merge;
9291   return left;
9292 #endif
9293 }
9294
9295 /* Extract the last identifier component of the qualified in WFL. The
9296    last identifier is removed from the linked list */
9297
9298 static tree
9299 cut_identifier_in_qualified (tree wfl)
9300 {
9301   tree q;
9302   tree previous = NULL_TREE;
9303   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9304     if (!TREE_CHAIN (q))
9305       {
9306         if (!previous)
9307           /* Operating on a non qualified qualified WFL.  */
9308           abort ();
9309
9310         TREE_CHAIN (previous) = NULL_TREE;
9311         return TREE_PURPOSE (q);
9312       }
9313 }
9314
9315 /* Resolve the expression name NAME. Return its decl.  */
9316
9317 static tree
9318 resolve_expression_name (tree id, tree *orig)
9319 {
9320   tree name = EXPR_WFL_NODE (id);
9321   tree decl;
9322
9323   /* 6.5.5.1: Simple expression names */
9324   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9325     {
9326       /* 15.13.1: NAME can appear within the scope of a local variable
9327          declaration */
9328       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9329         return decl;
9330
9331       /* 15.13.1: NAME can appear within a class declaration */
9332       else
9333         {
9334           decl = lookup_field_wrapper (current_class, name);
9335           if (decl)
9336             {
9337               tree access = NULL_TREE;
9338               int fs = FIELD_STATIC (decl);
9339
9340               /* If we're accessing an outer scope local alias, make
9341                  sure we change the name of the field we're going to
9342                  build access to. */
9343               if (FIELD_LOCAL_ALIAS_USED (decl))
9344                 name = DECL_NAME (decl);
9345
9346               check_deprecation (id, decl);
9347
9348               /* Instance variable (8.3.1.1) can't appear within
9349                  static method, static initializer or initializer for
9350                  a static variable. */
9351               if (!fs && METHOD_STATIC (current_function_decl))
9352                 {
9353                   static_ref_err (id, name, current_class);
9354                   return error_mark_node;
9355                 }
9356               /* Instance variables can't appear as an argument of
9357                  an explicit constructor invocation */
9358               if (!fs && ctxp->explicit_constructor_p
9359                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9360                 {
9361                   parse_error_context
9362                     (id, "Can't reference `%s' before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9363                   return error_mark_node;
9364                 }
9365
9366               /* If we're processing an inner class and we're trying
9367                  to access a field belonging to an outer class, build
9368                  the access to the field */
9369               if (!fs && outer_field_access_p (current_class, decl))
9370                 {
9371                   if (CLASS_STATIC (TYPE_NAME (current_class)))
9372                     {
9373                       static_ref_err (id, DECL_NAME (decl), current_class);
9374                       return error_mark_node;
9375                     }
9376                   access = build_outer_field_access (id, decl);
9377                   if (orig)
9378                     *orig = access;
9379                   return access;
9380                 }
9381
9382               /* Otherwise build what it takes to access the field */
9383               access = build_field_ref ((fs ? NULL_TREE : current_this),
9384                                         DECL_CONTEXT (decl), name);
9385               if (fs)
9386                 access = maybe_build_class_init_for_field (decl, access);
9387               /* We may be asked to save the real field access node */
9388               if (orig)
9389                 *orig = access;
9390               /* Last check: can we access the field? */
9391               if (not_accessible_p (current_class, decl, NULL_TREE, 0))
9392                 {
9393                   not_accessible_field_error (id, decl);
9394                   return error_mark_node;
9395                 }
9396               /* And we return what we got */
9397               return access;
9398             }
9399           /* Fall down to error report on undefined variable */
9400         }
9401     }
9402   /* 6.5.5.2 Qualified Expression Names */
9403   else
9404     {
9405       if (orig)
9406         *orig = NULL_TREE;
9407       qualify_ambiguous_name (id);
9408       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9409       /* 15.10.2: Accessing Superclass Members using super */
9410       return resolve_field_access (id, orig, NULL);
9411     }
9412
9413   /* We've got an error here */
9414   if (INNER_CLASS_TYPE_P (current_class))
9415     parse_error_context (id,
9416                          "Local variable `%s' can't be accessed from within the inner class `%s' unless it is declared final",
9417                          IDENTIFIER_POINTER (name),
9418                          IDENTIFIER_POINTER (DECL_NAME
9419                                              (TYPE_NAME (current_class))));
9420   else
9421     parse_error_context (id, "Undefined variable `%s'",
9422                          IDENTIFIER_POINTER (name));
9423
9424   return error_mark_node;
9425 }
9426
9427 static void
9428 static_ref_err (tree wfl, tree field_id, tree class_type)
9429 {
9430   parse_error_context
9431     (wfl,
9432      "Can't make a static reference to nonstatic variable `%s' in class `%s'",
9433      IDENTIFIER_POINTER (field_id),
9434      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9435 }
9436
9437 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9438    We return something suitable to generate the field access. We also
9439    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9440    recipient's address can be null. */
9441
9442 static tree
9443 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9444 {
9445   int is_static = 0;
9446   tree field_ref;
9447   tree decl, where_found, type_found;
9448
9449   if (resolve_qualified_expression_name (qual_wfl, &decl,
9450                                          &where_found, &type_found))
9451     return error_mark_node;
9452
9453   /* Resolve the LENGTH field of an array here */
9454   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9455       && type_found && TYPE_ARRAY_P (type_found)
9456       && ! flag_emit_class_files && ! flag_emit_xref)
9457     {
9458       tree length = build_java_array_length_access (where_found);
9459       field_ref = length;
9460
9461       /* In case we're dealing with a static array, we need to
9462          initialize its class before the array length can be fetched.
9463          It's also a good time to create a DECL_RTL for the field if
9464          none already exists, otherwise if the field was declared in a
9465          class found in an external file and hasn't been (and won't
9466          be) accessed for its value, none will be created. */
9467       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9468         {
9469           build_static_field_ref (where_found);
9470           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9471         }
9472     }
9473   /* We might have been trying to resolve field.method(). In which
9474      case, the resolution is over and decl is the answer */
9475   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9476     field_ref = decl;
9477   else if (JDECL_P (decl))
9478     {
9479       if (!type_found)
9480         type_found = DECL_CONTEXT (decl);
9481       is_static = FIELD_STATIC (decl);
9482       field_ref = build_field_ref ((is_static && !flag_emit_xref?
9483                                     NULL_TREE : where_found),
9484                                    type_found, DECL_NAME (decl));
9485       if (field_ref == error_mark_node)
9486         return error_mark_node;
9487       if (is_static)
9488         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9489
9490       /* If we're looking at a static field, we may need to generate a
9491          class initialization for it.  This can happen when the access
9492          looks like `field.ref', where `field' is a static field in an
9493          interface we implement.  */
9494       if (!flag_emit_class_files
9495           && !flag_emit_xref
9496           && TREE_CODE (where_found) == VAR_DECL
9497           && FIELD_STATIC (where_found))
9498         {
9499           build_static_field_ref (where_found);
9500           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9501         }
9502     }
9503   else
9504     field_ref = decl;
9505
9506   if (field_decl)
9507     *field_decl = decl;
9508   if (field_type)
9509     *field_type = (QUAL_DECL_TYPE (decl) ?
9510                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9511   return field_ref;
9512 }
9513
9514 /* If NODE is an access to f static field, strip out the class
9515    initialization part and return the field decl, otherwise, return
9516    NODE. */
9517
9518 static tree
9519 strip_out_static_field_access_decl (tree node)
9520 {
9521   if (TREE_CODE (node) == COMPOUND_EXPR)
9522     {
9523       tree op1 = TREE_OPERAND (node, 1);
9524       if (TREE_CODE (op1) == COMPOUND_EXPR)
9525          {
9526            tree call = TREE_OPERAND (op1, 0);
9527            if (TREE_CODE (call) == CALL_EXPR
9528                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9529                && TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9530                == soft_initclass_node)
9531              return TREE_OPERAND (op1, 1);
9532          }
9533       else if (JDECL_P (op1))
9534         return op1;
9535     }
9536   return node;
9537 }
9538
9539 /* 6.5.5.2: Qualified Expression Names */
9540
9541 static int
9542 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9543                                    tree *where_found, tree *type_found)
9544 {
9545   int from_type = 0;            /* Field search initiated from a type */
9546   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9547   int previous_call_static = 0;
9548   int is_static;
9549   tree decl = NULL_TREE, type = NULL_TREE, q;
9550   /* For certain for of inner class instantiation */
9551   tree saved_current, saved_this;
9552 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9553   { current_class = saved_current; current_this = saved_this;}
9554
9555   *type_found = *where_found = NULL_TREE;
9556
9557   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9558     {
9559       tree qual_wfl = QUAL_WFL (q);
9560       tree ret_decl;            /* for EH checking */
9561       int location;             /* for EH checking */
9562
9563       /* 15.10.1 Field Access Using a Primary */
9564       switch (TREE_CODE (qual_wfl))
9565         {
9566         case CALL_EXPR:
9567         case NEW_CLASS_EXPR:
9568           /* If the access to the function call is a non static field,
9569              build the code to access it. */
9570           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9571             {
9572               decl = maybe_access_field (decl, *where_found,
9573                                          DECL_CONTEXT (decl));
9574               if (decl == error_mark_node)
9575                 return 1;
9576             }
9577
9578           /* And code for the function call */
9579           if (complete_function_arguments (qual_wfl))
9580             return 1;
9581
9582           /* We might have to setup a new current class and a new this
9583              for the search of an inner class, relative to the type of
9584              a expression resolved as `decl'. The current values are
9585              saved and restored shortly after */
9586           saved_current = current_class;
9587           saved_this = current_this;
9588           if (decl
9589               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9590                   || from_qualified_this))
9591             {
9592               /* If we still have `from_qualified_this', we have the form
9593                  <T>.this.f() and we need to build <T>.this */
9594               if (from_qualified_this)
9595                 {
9596                   decl = build_access_to_thisn (current_class, type, 0);
9597                   decl = java_complete_tree (decl);
9598                   type = TREE_TYPE (TREE_TYPE (decl));
9599                 }
9600               current_class = type;
9601               current_this = decl;
9602               from_qualified_this = 0;
9603             }
9604
9605           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9606             CALL_USING_SUPER (qual_wfl) = 1;
9607           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9608                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9609           *where_found = patch_method_invocation (qual_wfl, decl, type,
9610                                                   from_super,
9611                                                   &is_static, &ret_decl);
9612           from_super = 0;
9613           if (*where_found == error_mark_node)
9614             {
9615               RESTORE_THIS_AND_CURRENT_CLASS;
9616               return 1;
9617             }
9618           *type_found = type = QUAL_DECL_TYPE (*where_found);
9619
9620           *where_found = force_evaluation_order (*where_found);
9621
9622           /* If we're creating an inner class instance, check for that
9623              an enclosing instance is in scope */
9624           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9625               && INNER_ENCLOSING_SCOPE_CHECK (type))
9626             {
9627               parse_error_context
9628                 (qual_wfl, "No enclosing instance for inner class `%s' is in scope%s",
9629                  lang_printable_name (type, 0),
9630                  (!current_this ? "" :
9631                   "; an explicit one must be provided when creating this inner class"));
9632               RESTORE_THIS_AND_CURRENT_CLASS;
9633               return 1;
9634             }
9635
9636           /* In case we had to change then to resolve a inner class
9637              instantiation using a primary qualified by a `new' */
9638           RESTORE_THIS_AND_CURRENT_CLASS;
9639
9640           if (location)
9641             {
9642               tree arguments = NULL_TREE;
9643               if (TREE_CODE (qual_wfl) == CALL_EXPR
9644                   && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9645                 arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9646               check_thrown_exceptions (location, ret_decl, arguments);
9647             }
9648
9649           /* If the previous call was static and this one is too,
9650              build a compound expression to hold the two (because in
9651              that case, previous function calls aren't transported as
9652              forcoming function's argument. */
9653           if (previous_call_static && is_static)
9654             {
9655               decl = build (COMPOUND_EXPR, TREE_TYPE (*where_found),
9656                             decl, *where_found);
9657               TREE_SIDE_EFFECTS (decl) = 1;
9658             }
9659           else
9660             {
9661               previous_call_static = is_static;
9662               decl = *where_found;
9663             }
9664           from_type = 0;
9665           continue;
9666
9667         case NEW_ARRAY_EXPR:
9668         case NEW_ANONYMOUS_ARRAY_EXPR:
9669           *where_found = decl = java_complete_tree (qual_wfl);
9670           if (decl == error_mark_node)
9671             return 1;
9672           *type_found = type = QUAL_DECL_TYPE (decl);
9673           continue;
9674
9675         case CONVERT_EXPR:
9676           *where_found = decl = java_complete_tree (qual_wfl);
9677           if (decl == error_mark_node)
9678             return 1;
9679           *type_found = type = QUAL_DECL_TYPE (decl);
9680           from_cast = 1;
9681           continue;
9682
9683         case CONDITIONAL_EXPR:
9684         case STRING_CST:
9685         case MODIFY_EXPR:
9686           *where_found = decl = java_complete_tree (qual_wfl);
9687           if (decl == error_mark_node)
9688             return 1;
9689           *type_found = type = QUAL_DECL_TYPE (decl);
9690           continue;
9691
9692         case ARRAY_REF:
9693           /* If the access to the function call is a non static field,
9694              build the code to access it. */
9695           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9696             {
9697               decl = maybe_access_field (decl, *where_found, type);
9698               if (decl == error_mark_node)
9699                 return 1;
9700             }
9701           /* And code for the array reference expression */
9702           decl = java_complete_tree (qual_wfl);
9703           if (decl == error_mark_node)
9704             return 1;
9705           type = QUAL_DECL_TYPE (decl);
9706           continue;
9707
9708         case PLUS_EXPR:
9709           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9710             return 1;
9711           if ((type = patch_string (decl)))
9712             decl = type;
9713           *where_found = QUAL_RESOLUTION (q) = decl;
9714           *type_found = type = TREE_TYPE (decl);
9715           break;
9716
9717         case CLASS_LITERAL:
9718           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9719             return 1;
9720           *where_found = QUAL_RESOLUTION (q) = decl;
9721           *type_found = type = TREE_TYPE (decl);
9722           break;
9723
9724         default:
9725           /* Fix for -Wall Just go to the next statement. Don't
9726              continue */
9727           break;
9728         }
9729
9730       /* If we fall here, we weren't processing a (static) function call. */
9731       previous_call_static = 0;
9732
9733       /* It can be the keyword THIS */
9734       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9735           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9736         {
9737           if (!current_this)
9738             {
9739               parse_error_context
9740                 (wfl, "Keyword `this' used outside allowed context");
9741               return 1;
9742             }
9743           if (ctxp->explicit_constructor_p
9744               && type == current_class)
9745             {
9746               parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
9747               return 1;
9748             }
9749           /* We have to generate code for intermediate access */
9750           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9751             {
9752               *where_found = decl = current_this;
9753               *type_found = type = QUAL_DECL_TYPE (decl);
9754             }
9755           /* We're trying to access the this from somewhere else. Make sure
9756              it's allowed before doing so. */
9757           else
9758             {
9759               if (!enclosing_context_p (type, current_class))
9760                 {
9761                   char *p  = xstrdup (lang_printable_name (type, 0));
9762                   parse_error_context (qual_wfl, "Can't use variable `%s.this': type `%s' isn't an outer type of type `%s'",
9763                                        p, p,
9764                                        lang_printable_name (current_class, 0));
9765                   free (p);
9766                   return 1;
9767                 }
9768               from_qualified_this = 1;
9769               /* If there's nothing else after that, we need to
9770                  produce something now, otherwise, the section of the
9771                  code that needs to produce <T>.this will generate
9772                  what is necessary. */
9773               if (!TREE_CHAIN (q))
9774                 {
9775                   decl = build_access_to_thisn (current_class, type, 0);
9776                   *where_found = decl = java_complete_tree (decl);
9777                   *type_found = type = TREE_TYPE (decl);
9778                 }
9779             }
9780
9781           from_type = 0;
9782           continue;
9783         }
9784
9785       /* 15.10.2 Accessing Superclass Members using SUPER */
9786       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9787           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9788         {
9789           tree node;
9790           /* Check on the restricted use of SUPER */
9791           if (METHOD_STATIC (current_function_decl)
9792               || current_class == object_type_node)
9793             {
9794               parse_error_context
9795                 (wfl, "Keyword `super' used outside allowed context");
9796               return 1;
9797             }
9798           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9799           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9800                              CLASSTYPE_SUPER (current_class),
9801                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9802           *where_found = decl = java_complete_tree (node);
9803           if (decl == error_mark_node)
9804             return 1;
9805           *type_found = type = QUAL_DECL_TYPE (decl);
9806           from_super = from_type = 1;
9807           continue;
9808         }
9809
9810       /* 15.13.1: Can't search for field name in packages, so we
9811          assume a variable/class name was meant. */
9812       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9813         {
9814           tree name;
9815           if ((decl = resolve_package (wfl, &q, &name)))
9816             {
9817               tree list;
9818               *where_found = decl;
9819
9820               /* We want to be absolutely sure that the class is laid
9821                  out. We're going to search something inside it. */
9822               *type_found = type = TREE_TYPE (decl);
9823               layout_class (type);
9824               from_type = 1;
9825
9826               /* Fix them all the way down, if any are left. */
9827               if (q)
9828                 {
9829                   list = TREE_CHAIN (q);
9830                   while (list)
9831                     {
9832                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9833                       list = TREE_CHAIN (list);
9834                     }
9835                 }
9836             }
9837           else
9838             {
9839               if (from_super || from_cast)
9840                 parse_error_context
9841                   ((from_cast ? qual_wfl : wfl),
9842                    "No variable `%s' defined in class `%s'",
9843                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9844                    lang_printable_name (type, 0));
9845               else
9846                 parse_error_context
9847                   (qual_wfl, "Undefined variable or class name: `%s'",
9848                    IDENTIFIER_POINTER (name));
9849               return 1;
9850             }
9851         }
9852
9853       /* We have a type name. It's been already resolved when the
9854          expression was qualified. */
9855       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9856         {
9857           decl = QUAL_RESOLUTION (q);
9858
9859           /* Sneak preview. If next we see a `new', we're facing a
9860              qualification with resulted in a type being selected
9861              instead of a field.  Report the error */
9862           if(TREE_CHAIN (q)
9863              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9864             {
9865               parse_error_context (qual_wfl, "Undefined variable `%s'",
9866                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9867               return 1;
9868             }
9869
9870           if (not_accessible_p (TREE_TYPE (decl), decl, type, 0))
9871             return not_accessible_field_error (qual_wfl, decl);
9872           check_deprecation (qual_wfl, decl);
9873
9874           type = TREE_TYPE (decl);
9875           from_type = 1;
9876         }
9877       /* We resolve an expression name */
9878       else
9879         {
9880           tree field_decl = NULL_TREE;
9881
9882           /* If there exists an early resolution, use it. That occurs
9883              only once and we know that there are more things to
9884              come. Don't do that when processing something after SUPER
9885              (we need more thing to be put in place below */
9886           if (!from_super && QUAL_RESOLUTION (q))
9887             {
9888               decl = QUAL_RESOLUTION (q);
9889               if (!type)
9890                 {
9891                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
9892                     {
9893                       if (current_this)
9894                         *where_found = current_this;
9895                       else
9896                         {
9897                           static_ref_err (qual_wfl, DECL_NAME (decl),
9898                                           current_class);
9899                           return 1;
9900                         }
9901                       if (outer_field_access_p (current_class, decl))
9902                         decl = build_outer_field_access (qual_wfl, decl);
9903                     }
9904                   else
9905                     {
9906                       *where_found = TREE_TYPE (decl);
9907                       if (TREE_CODE (*where_found) == POINTER_TYPE)
9908                         *where_found = TREE_TYPE (*where_found);
9909                     }
9910                 }
9911             }
9912
9913           /* Report and error if we're using a numerical literal as a
9914              qualifier. It can only be an INTEGER_CST. */
9915           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
9916             {
9917               parse_error_context
9918                 (wfl, "Can't use type `%s' as a qualifier",
9919                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
9920               return 1;
9921             }
9922
9923           /* We have to search for a field, knowing the type of its
9924              container. The flag FROM_TYPE indicates that we resolved
9925              the last member of the expression as a type name, which
9926              means that for the resolution of this field, we'll look
9927              for other errors than if it was resolved as a member of
9928              an other field. */
9929           else
9930             {
9931               int is_static;
9932               tree field_decl_type; /* For layout */
9933
9934               if (!from_type && !JREFERENCE_TYPE_P (type))
9935                 {
9936                   parse_error_context
9937                     (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
9938                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9939                      lang_printable_name (type, 0),
9940                      IDENTIFIER_POINTER (DECL_NAME (decl)));
9941                   return 1;
9942                 }
9943
9944               field_decl = lookup_field_wrapper (type,
9945                                                  EXPR_WFL_NODE (qual_wfl));
9946
9947               /* Maybe what we're trying to access to is an inner
9948                  class, only if decl is a TYPE_DECL. */
9949               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
9950                 {
9951                   tree ptr, inner_decl;
9952
9953                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
9954                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
9955                   if (inner_decl)
9956                     {
9957                       check_inner_class_access (inner_decl, decl, qual_wfl);
9958                       type = TREE_TYPE (inner_decl);
9959                       decl = inner_decl;
9960                       from_type = 1;
9961                       continue;
9962                     }
9963                 }
9964
9965               if (field_decl == NULL_TREE)
9966                 {
9967                   parse_error_context
9968                     (qual_wfl, "No variable `%s' defined in type `%s'",
9969                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9970                      GET_TYPE_NAME (type));
9971                   return 1;
9972                 }
9973               if (field_decl == error_mark_node)
9974                 return 1;
9975
9976               /* Layout the type of field_decl, since we may need
9977                  it. Don't do primitive types or loaded classes. The
9978                  situation of non primitive arrays may not handled
9979                  properly here. FIXME */
9980               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
9981                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
9982               else
9983                 field_decl_type = TREE_TYPE (field_decl);
9984               if (!JPRIMITIVE_TYPE_P (field_decl_type)
9985                   && !CLASS_LOADED_P (field_decl_type)
9986                   && !TYPE_ARRAY_P (field_decl_type))
9987                 resolve_and_layout (field_decl_type, NULL_TREE);
9988
9989               /* Check on accessibility here */
9990               if (not_accessible_p (current_class, field_decl,
9991                                     DECL_CONTEXT (field_decl), from_super))
9992                 return not_accessible_field_error (qual_wfl,field_decl);
9993               check_deprecation (qual_wfl, field_decl);
9994
9995               /* There are things to check when fields are accessed
9996                  from type. There are no restrictions on a static
9997                  declaration of the field when it is accessed from an
9998                  interface */
9999               is_static = FIELD_STATIC (field_decl);
10000               if (!from_super && from_type
10001                   && !TYPE_INTERFACE_P (type)
10002                   && !is_static
10003                   && (current_function_decl
10004                       && METHOD_STATIC (current_function_decl)))
10005                 {
10006                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
10007                   return 1;
10008                 }
10009               from_cast = from_super = 0;
10010
10011               /* It's an access from a type but it isn't static, we
10012                  make it relative to `this'. */
10013               if (!is_static && from_type)
10014                 decl = current_this;
10015
10016               /* If we need to generate something to get a proper
10017                  handle on what this field is accessed from, do it
10018                  now. */
10019               if (!is_static)
10020                 {
10021                   decl = maybe_access_field (decl, *where_found, *type_found);
10022                   if (decl == error_mark_node)
10023                     return 1;
10024                 }
10025
10026               /* We want to keep the location were found it, and the type
10027                  we found. */
10028               *where_found = decl;
10029               *type_found = type;
10030
10031               /* Generate the correct expression for field access from
10032                  qualified this */
10033               if (from_qualified_this)
10034                 {
10035                   field_decl = build_outer_field_access (qual_wfl, field_decl);
10036                   from_qualified_this = 0;
10037                 }
10038
10039               /* This is the decl found and eventually the next one to
10040                  search from */
10041               decl = field_decl;
10042             }
10043           from_type = 0;
10044           type = QUAL_DECL_TYPE (decl);
10045
10046           /* Sneak preview. If decl is qualified by a `new', report
10047              the error here to be accurate on the peculiar construct */
10048           if (TREE_CHAIN (q)
10049               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10050               && !JREFERENCE_TYPE_P (type))
10051             {
10052               parse_error_context (qual_wfl, "Attempt to reference field `new' in a `%s'",
10053                                    lang_printable_name (type, 0));
10054               return 1;
10055             }
10056         }
10057       /* `q' might have changed due to a after package resolution
10058          re-qualification */
10059       if (!q)
10060         break;
10061     }
10062   *found_decl = decl;
10063   return 0;
10064 }
10065
10066 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10067    can't be accessed from REFERENCE (a record type). If MEMBER
10068    features a protected access, we then use WHERE which, if non null,
10069    holds the type of MEMBER's access that is checked against
10070    6.6.2.1. This function should be used when decl is a field or a
10071    method.  */
10072
10073 static int
10074 not_accessible_p (tree reference, tree member, tree where, int from_super)
10075 {
10076   int access_flag = get_access_flags_from_decl (member);
10077
10078   /* Inner classes are processed by check_inner_class_access */
10079   if (INNER_CLASS_TYPE_P (reference))
10080     return 0;
10081
10082   /* Access always granted for members declared public */
10083   if (access_flag & ACC_PUBLIC)
10084     return 0;
10085
10086   /* Check access on protected members */
10087   if (access_flag & ACC_PROTECTED)
10088     {
10089       /* Access granted if it occurs from within the package
10090          containing the class in which the protected member is
10091          declared */
10092       if (class_in_current_package (DECL_CONTEXT (member)))
10093         return 0;
10094
10095       /* If accessed with the form `super.member', then access is granted */
10096       if (from_super)
10097         return 0;
10098
10099       /* If where is active, access was made through a
10100          qualifier. Access is granted if the type of the qualifier is
10101          or is a sublass of the type the access made from (6.6.2.1.)  */
10102       if (where && !inherits_from_p (reference, where))
10103         return 1;
10104
10105       /* Otherwise, access is granted if occurring from the class where
10106          member is declared or a subclass of it. Find the right
10107          context to perform the check */
10108       if (PURE_INNER_CLASS_TYPE_P (reference))
10109         {
10110           while (INNER_CLASS_TYPE_P (reference))
10111             {
10112               if (inherits_from_p (reference, DECL_CONTEXT (member)))
10113                 return 0;
10114               reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10115             }
10116         }
10117       if (inherits_from_p (reference, DECL_CONTEXT (member)))
10118         return 0;
10119       return 1;
10120     }
10121
10122   /* Check access on private members. Access is granted only if it
10123      occurs from within the class in which it is declared -- that does
10124      it for innerclasses too. */
10125   if (access_flag & ACC_PRIVATE)
10126     {
10127       if (reference == DECL_CONTEXT (member))
10128         return 0;
10129       if (enclosing_context_p (reference, DECL_CONTEXT (member)))
10130         return 0;
10131       return 1;
10132     }
10133
10134   /* Default access are permitted only when occurring within the
10135      package in which the type (REFERENCE) is declared. In other words,
10136      REFERENCE is defined in the current package */
10137   if (ctxp->package)
10138     return !class_in_current_package (reference);
10139
10140   /* Otherwise, access is granted */
10141   return 0;
10142 }
10143
10144 /* Test deprecated decl access.  */
10145 static void
10146 check_deprecation (tree wfl, tree decl)
10147 {
10148   const char *file;
10149   tree elt;
10150
10151   if (! flag_deprecated)
10152     return;
10153
10154   /* We want to look at the element type of arrays here, so we strip
10155      all surrounding array types.  */
10156   if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10157     {
10158       elt = TREE_TYPE (decl);
10159       while (TYPE_ARRAY_P (elt))
10160         elt = TYPE_ARRAY_ELEMENT (elt);
10161       /* We'll end up with a pointer type, so we use TREE_TYPE to go
10162          to the record.  */
10163       decl = TYPE_NAME (TREE_TYPE (elt));
10164     }
10165   file = DECL_SOURCE_FILE (decl);
10166
10167   /* Complain if the field is deprecated and the file it was defined
10168      in isn't compiled at the same time the file which contains its
10169      use is */
10170   if (DECL_DEPRECATED (decl)
10171       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10172     {
10173       const char *the;
10174       switch (TREE_CODE (decl))
10175         {
10176         case FUNCTION_DECL:
10177           the = "method";
10178           break;
10179         case FIELD_DECL:
10180         case VAR_DECL:
10181           the = "field";
10182           break;
10183         case TYPE_DECL:
10184           parse_warning_context (wfl, "The class `%s' has been deprecated",
10185                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10186           return;
10187         default:
10188           abort ();
10189         }
10190       /* Don't issue a message if the context as been deprecated as a
10191          whole. */
10192       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10193         parse_warning_context
10194           (wfl, "The %s `%s' in class `%s' has been deprecated",
10195            the, lang_printable_name (decl, 0),
10196            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10197     }
10198 }
10199
10200 /* Returns 1 if class was declared in the current package, 0 otherwise */
10201
10202 static GTY(()) tree cicp_cache;
10203 static int
10204 class_in_current_package (tree class)
10205 {
10206   int qualified_flag;
10207   tree left;
10208
10209   if (cicp_cache == class)
10210     return 1;
10211
10212   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10213
10214   /* If the current package is empty and the name of CLASS is
10215      qualified, class isn't in the current package.  If there is a
10216      current package and the name of the CLASS is not qualified, class
10217      isn't in the current package */
10218   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10219     return 0;
10220
10221   /* If there is not package and the name of CLASS isn't qualified,
10222      they belong to the same unnamed package */
10223   if (!ctxp->package && !qualified_flag)
10224     return 1;
10225
10226   /* Compare the left part of the name of CLASS with the package name */
10227   breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10228   if (ctxp->package == left)
10229     {
10230       cicp_cache = class;
10231       return 1;
10232     }
10233   return 0;
10234 }
10235
10236 /* This function may generate code to access DECL from WHERE. This is
10237    done only if certain conditions meet.  */
10238
10239 static tree
10240 maybe_access_field (tree decl, tree where, tree type)
10241 {
10242   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10243       && !FIELD_STATIC (decl))
10244     decl = build_field_ref (where ? where : current_this,
10245                             (type ? type : DECL_CONTEXT (decl)),
10246                             DECL_NAME (decl));
10247   return decl;
10248 }
10249
10250 /* Build a method invocation, by patching PATCH. If non NULL
10251    and according to the situation, PRIMARY and WHERE may be
10252    used. IS_STATIC is set to 1 if the invoked function is static. */
10253
10254 static tree
10255 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10256                          int *is_static, tree *ret_decl)
10257 {
10258   tree wfl = TREE_OPERAND (patch, 0);
10259   tree args = TREE_OPERAND (patch, 1);
10260   tree name = EXPR_WFL_NODE (wfl);
10261   tree list;
10262   int is_static_flag = 0;
10263   int is_super_init = 0;
10264   tree this_arg = NULL_TREE;
10265   int is_array_clone_call = 0;
10266
10267   /* Should be overridden if everything goes well. Otherwise, if
10268      something fails, it should keep this value. It stop the
10269      evaluation of a bogus assignment. See java_complete_tree,
10270      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10271      evaluating an assignment */
10272   TREE_TYPE (patch) = error_mark_node;
10273
10274   /* Since lookup functions are messing with line numbers, save the
10275      context now.  */
10276   java_parser_context_save_global ();
10277
10278   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10279
10280   /* Resolution of qualified name, excluding constructors */
10281   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10282     {
10283       tree identifier, identifier_wfl, type, resolved;
10284       /* Extract the last IDENTIFIER of the qualified
10285          expression. This is a wfl and we will use it's location
10286          data during error report. */
10287       identifier_wfl = cut_identifier_in_qualified (wfl);
10288       identifier = EXPR_WFL_NODE (identifier_wfl);
10289
10290       /* Given the context, IDENTIFIER is syntactically qualified
10291          as a MethodName. We need to qualify what's before */
10292       qualify_ambiguous_name (wfl);
10293       resolved = resolve_field_access (wfl, NULL, NULL);
10294
10295       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10296          && FIELD_FINAL (resolved)
10297          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10298          && !flag_emit_class_files && !flag_emit_xref)
10299        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10300
10301       if (resolved == error_mark_node)
10302         PATCH_METHOD_RETURN_ERROR ();
10303
10304       type = GET_SKIP_TYPE (resolved);
10305       resolve_and_layout (type, NULL_TREE);
10306
10307       if (JPRIMITIVE_TYPE_P (type))
10308         {
10309           parse_error_context
10310             (identifier_wfl,
10311              "Can't invoke a method on primitive type `%s'",
10312              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10313           PATCH_METHOD_RETURN_ERROR ();
10314         }
10315
10316       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10317       args = nreverse (args);
10318
10319       /* We're resolving a call from a type */
10320       if (TREE_CODE (resolved) == TYPE_DECL)
10321         {
10322           if (CLASS_INTERFACE (resolved))
10323             {
10324               parse_error_context
10325                 (identifier_wfl,
10326                 "Can't make static reference to method `%s' in interface `%s'",
10327                  IDENTIFIER_POINTER (identifier),
10328                  IDENTIFIER_POINTER (name));
10329               PATCH_METHOD_RETURN_ERROR ();
10330             }
10331           if (list && !METHOD_STATIC (list))
10332             {
10333               char *fct_name = xstrdup (lang_printable_name (list, 0));
10334               parse_error_context
10335                 (identifier_wfl,
10336                  "Can't make static reference to method `%s %s' in class `%s'",
10337                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10338                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10339               free (fct_name);
10340               PATCH_METHOD_RETURN_ERROR ();
10341             }
10342         }
10343       else
10344         this_arg = primary = resolved;
10345
10346       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10347         is_array_clone_call = 1;
10348
10349       /* IDENTIFIER_WFL will be used to report any problem further */
10350       wfl = identifier_wfl;
10351     }
10352   /* Resolution of simple names, names generated after a primary: or
10353      constructors */
10354   else
10355     {
10356       tree class_to_search = NULL_TREE;
10357       int lc;                   /* Looking for Constructor */
10358
10359       /* We search constructor in their target class */
10360       if (CALL_CONSTRUCTOR_P (patch))
10361         {
10362           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10363             class_to_search = EXPR_WFL_NODE (wfl);
10364           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10365                    this_identifier_node)
10366             class_to_search = NULL_TREE;
10367           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10368                    super_identifier_node)
10369             {
10370               is_super_init = 1;
10371               if (CLASSTYPE_SUPER (current_class))
10372                 class_to_search =
10373                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10374               else
10375                 {
10376                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10377                   PATCH_METHOD_RETURN_ERROR ();
10378                 }
10379             }
10380
10381           /* Class to search is NULL if we're searching the current one */
10382           if (class_to_search)
10383             {
10384               class_to_search = resolve_and_layout (class_to_search, wfl);
10385
10386               if (!class_to_search)
10387                 {
10388                   parse_error_context
10389                     (wfl, "Class `%s' not found in type declaration",
10390                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10391                   PATCH_METHOD_RETURN_ERROR ();
10392                 }
10393
10394               /* Can't instantiate an abstract class, but we can
10395                  invoke it's constructor. It's use within the `new'
10396                  context is denied here. */
10397               if (CLASS_ABSTRACT (class_to_search)
10398                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10399                 {
10400                   parse_error_context
10401                     (wfl, "Class `%s' is an abstract class. It can't be instantiated",
10402                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10403                   PATCH_METHOD_RETURN_ERROR ();
10404                 }
10405
10406               class_to_search = TREE_TYPE (class_to_search);
10407             }
10408           else
10409             class_to_search = current_class;
10410           lc = 1;
10411         }
10412       /* This is a regular search in the local class, unless an
10413          alternate class is specified. */
10414       else
10415         {
10416           if (where != NULL_TREE)
10417             class_to_search = where;
10418           else if (QUALIFIED_P (name))
10419             class_to_search = current_class;
10420           else
10421             {
10422               class_to_search = current_class;
10423
10424               for (;;)
10425                 {
10426                   if (has_method (class_to_search, name))
10427                     break;
10428                   if (! INNER_CLASS_TYPE_P (class_to_search))
10429                     {
10430                       parse_error_context (wfl,
10431                                            "No method named `%s' in scope",
10432                                            IDENTIFIER_POINTER (name));
10433                       PATCH_METHOD_RETURN_ERROR ();
10434                     }
10435                   class_to_search
10436                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10437                 }
10438             }
10439           lc = 0;
10440         }
10441
10442       /* NAME is a simple identifier or comes from a primary. Search
10443          in the class whose declaration contain the method being
10444          invoked. */
10445       resolve_and_layout (class_to_search, NULL_TREE);
10446
10447       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10448       /* Don't continue if no method were found, as the next statement
10449          can't be executed then. */
10450       if (!list)
10451         PATCH_METHOD_RETURN_ERROR ();
10452
10453       if (TYPE_ARRAY_P (class_to_search)
10454           && DECL_NAME (list) == get_identifier ("clone"))
10455         is_array_clone_call = 1;
10456
10457       /* Check for static reference if non static methods */
10458       if (check_for_static_method_reference (wfl, patch, list,
10459                                              class_to_search, primary))
10460         PATCH_METHOD_RETURN_ERROR ();
10461
10462       /* Check for inner classes creation from illegal contexts */
10463       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10464                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10465           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10466           && !DECL_INIT_P (current_function_decl))
10467         {
10468           parse_error_context
10469             (wfl, "No enclosing instance for inner class `%s' is in scope%s",
10470              lang_printable_name (class_to_search, 0),
10471              (!current_this ? "" :
10472               "; an explicit one must be provided when creating this inner class"));
10473           PATCH_METHOD_RETURN_ERROR ();
10474         }
10475
10476       /* Non static methods are called with the current object extra
10477          argument. If patch a `new TYPE()', the argument is the value
10478          returned by the object allocator. If method is resolved as a
10479          primary, use the primary otherwise use the current THIS. */
10480       args = nreverse (args);
10481       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10482         {
10483           this_arg = primary ? primary : current_this;
10484
10485           /* If we're using an access method, things are different.
10486              There are two family of cases:
10487
10488              1) We're not generating bytecodes:
10489
10490              - LIST is non static. It's invocation is transformed from
10491                x(a1,...,an) into this$<n>.x(a1,....an).
10492              - LIST is static. It's invocation is transformed from
10493                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10494
10495              2) We're generating bytecodes:
10496
10497              - LIST is non static. It's invocation is transformed from
10498                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10499              - LIST is static. It's invocation is transformed from
10500                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10501
10502              Of course, this$<n> can be arbitrarily complex, ranging from
10503              this$0 (the immediate outer context) to
10504              access$0(access$0(...(this$0))).
10505
10506              maybe_use_access_method returns a nonzero value if the
10507              this_arg has to be moved into the (then generated) stub
10508              argument list. In the meantime, the selected function
10509              might have be replaced by a generated stub. */
10510           if (!primary &&
10511               maybe_use_access_method (is_super_init, &list, &this_arg))
10512             {
10513               args = tree_cons (NULL_TREE, this_arg, args);
10514               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10515             }
10516         }
10517     }
10518
10519   /* Merge point of all resolution schemes. If we have nothing, this
10520      is an error, already signaled */
10521   if (!list)
10522     PATCH_METHOD_RETURN_ERROR ();
10523
10524   /* Check accessibility, position the is_static flag, build and
10525      return the call */
10526   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10527                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10528                          NULL_TREE), from_super)
10529       /* Calls to clone() on array types are permitted as a special-case. */
10530       && !is_array_clone_call)
10531     {
10532       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10533       const char *const access =
10534         java_accstring_lookup (get_access_flags_from_decl (list));
10535       const char *const klass =
10536         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10537       const char *const refklass =
10538         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10539       const char *const what = (DECL_CONSTRUCTOR_P (list)
10540                                 ? "constructor" : "method");
10541       /* FIXME: WFL yields the wrong message here but I don't know
10542          what else to use.  */
10543       parse_error_context (wfl,
10544                            "Can't access %s %s `%s.%s' from `%s'",
10545                            access, what, klass, fct_name, refklass);
10546       PATCH_METHOD_RETURN_ERROR ();
10547     }
10548
10549   /* Deprecation check: check whether the method being invoked or the
10550      instance-being-created's type are deprecated.  */
10551   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10552     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10553   check_deprecation (wfl, list);
10554
10555   /* If invoking a innerclass constructor, there are hidden parameters
10556      to pass */
10557   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10558       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10559     {
10560       /* And make sure we add the accessed local variables to be saved
10561          in field aliases. */
10562       args = build_alias_initializer_parameter_list
10563         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10564
10565       /* Secretly pass the current_this/primary as a second argument */
10566       if (primary || current_this)
10567         {
10568           tree extra_arg;
10569           tree this_type = (current_this ?
10570                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10571           /* Method's (list) enclosing context */
10572           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10573           /* If we have a primary, use it. */
10574           if (primary)
10575             extra_arg = primary;
10576           /* The current `this' is an inner class but isn't a direct
10577              enclosing context for the inner class we're trying to
10578              create. Build an access to the proper enclosing context
10579              and use it. */
10580           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10581                    && this_type != TREE_TYPE (mec))
10582             {
10583
10584               extra_arg = build_access_to_thisn (current_class,
10585                                                  TREE_TYPE (mec), 0);
10586               extra_arg = java_complete_tree (extra_arg);
10587             }
10588           /* Otherwise, just use the current `this' as an enclosing
10589              context. */
10590           else
10591             extra_arg = current_this;
10592           args = tree_cons (NULL_TREE, extra_arg, args);
10593         }
10594       else
10595         args = tree_cons (NULL_TREE, integer_zero_node, args);
10596     }
10597
10598   /* This handles the situation where a constructor invocation needs
10599      to have an enclosing context passed as a second parameter (the
10600      constructor is one of an inner class). */
10601   if ((is_super_init ||
10602        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10603       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10604     {
10605       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10606       tree extra_arg =
10607         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10608       extra_arg = java_complete_tree (extra_arg);
10609       args = tree_cons (NULL_TREE, extra_arg, args);
10610     }
10611
10612   is_static_flag = METHOD_STATIC (list);
10613   if (! is_static_flag && this_arg != NULL_TREE)
10614     args = tree_cons (NULL_TREE, this_arg, args);
10615
10616   /* In the context of an explicit constructor invocation, we can't
10617      invoke any method relying on `this'. Exceptions are: we're
10618      invoking a static function, primary exists and is not the current
10619      this, we're creating a new object. */
10620   if (ctxp->explicit_constructor_p
10621       && !is_static_flag
10622       && (!primary || primary == current_this)
10623       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10624     {
10625       parse_error_context (wfl, "Can't reference `this' before the superclass constructor has been called");
10626       PATCH_METHOD_RETURN_ERROR ();
10627     }
10628   java_parser_context_restore_global ();
10629   if (is_static)
10630     *is_static = is_static_flag;
10631   /* Sometimes, we want the decl of the selected method. Such as for
10632      EH checking */
10633   if (ret_decl)
10634     *ret_decl = list;
10635   patch = patch_invoke (patch, list, args);
10636
10637   /* Now is a good time to insert the call to finit$ */
10638   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10639     {
10640       tree finit_parms, finit_call;
10641
10642       /* Prepare to pass hidden parameters to finit$, if any. */
10643       finit_parms = build_alias_initializer_parameter_list
10644         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10645
10646       finit_call =
10647         build_method_invocation (build_wfl_node (finit_identifier_node),
10648                                  finit_parms);
10649
10650       /* Generate the code used to initialize fields declared with an
10651          initialization statement and build a compound statement along
10652          with the super constructor invocation. */
10653       CAN_COMPLETE_NORMALLY (patch) = 1;
10654       patch = build (COMPOUND_EXPR, void_type_node, patch,
10655                      java_complete_tree (finit_call));
10656     }
10657   return patch;
10658 }
10659
10660 /* Check that we're not trying to do a static reference to a method in
10661    non static method. Return 1 if it's the case, 0 otherwise. */
10662
10663 static int
10664 check_for_static_method_reference (tree wfl, tree node, tree method,
10665                                    tree where, tree primary)
10666 {
10667   if (METHOD_STATIC (current_function_decl)
10668       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10669     {
10670       char *fct_name = xstrdup (lang_printable_name (method, 0));
10671       parse_error_context
10672         (wfl, "Can't make static reference to method `%s %s' in class `%s'",
10673          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10674          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10675       free (fct_name);
10676       return 1;
10677     }
10678   return 0;
10679 }
10680
10681 /* Fix the invocation of *MDECL if necessary in the case of a
10682    invocation from an inner class. *THIS_ARG might be modified
10683    appropriately and an alternative access to *MDECL might be
10684    returned.  */
10685
10686 static int
10687 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10688 {
10689   tree ctx;
10690   tree md = *mdecl, ta = *this_arg;
10691   int to_return = 0;
10692   int non_static_context = !METHOD_STATIC (md);
10693
10694   if (is_super_init
10695       || DECL_CONTEXT (md) == current_class
10696       || !PURE_INNER_CLASS_TYPE_P (current_class)
10697       || DECL_FINIT_P (md)
10698       || DECL_INSTINIT_P (md))
10699     return 0;
10700
10701   /* If we're calling a method found in an enclosing class, generate
10702      what it takes to retrieve the right this. Don't do that if we're
10703      invoking a static method. Note that if MD's type is unrelated to
10704      CURRENT_CLASS, then the current this can be used. */
10705
10706   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10707     {
10708       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10709       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10710         {
10711           ta = build_current_thisn (current_class);
10712           ta = build_wfl_node (ta);
10713         }
10714       else
10715         {
10716           tree type = ctx;
10717           while (type)
10718             {
10719               maybe_build_thisn_access_method (type);
10720               if (inherits_from_p (type, DECL_CONTEXT (md)))
10721                 {
10722                   ta = build_access_to_thisn (ctx, type, 0);
10723                   break;
10724                 }
10725               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10726                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10727             }
10728         }
10729       ta = java_complete_tree (ta);
10730     }
10731
10732   /* We might have to use an access method to get to MD. We can
10733      break the method access rule as far as we're not generating
10734      bytecode */
10735   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10736     {
10737       md = build_outer_method_access_method (md);
10738       to_return = 1;
10739     }
10740
10741   *mdecl = md;
10742   *this_arg = ta;
10743
10744   /* Returning a nonzero value indicates we were doing a non static
10745      method invocation that is now a static invocation. It will have
10746      callee displace `this' to insert it in the regular argument
10747      list. */
10748   return (non_static_context && to_return);
10749 }
10750
10751 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10752    mode.  */
10753
10754 static tree
10755 patch_invoke (tree patch, tree method, tree args)
10756 {
10757   tree dtable, func;
10758   tree original_call, t, ta;
10759   tree check = NULL_TREE;
10760
10761   /* Last step for args: convert build-in types. If we're dealing with
10762      a new TYPE() type call, the first argument to the constructor
10763      isn't found in the incoming argument list, but delivered by
10764      `new' */
10765   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10766   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10767     t = TREE_CHAIN (t);
10768   for (ta = args; t != end_params_node && ta;
10769        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10770     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10771         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10772       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10773
10774   /* Resolve unresolved returned type issues */
10775   t = TREE_TYPE (TREE_TYPE (method));
10776   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10777     resolve_and_layout (TREE_TYPE (t), NULL);
10778
10779   if (flag_emit_class_files || flag_emit_xref)
10780     func = method;
10781   else
10782     {
10783       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10784         {
10785         case INVOKE_VIRTUAL:
10786           dtable = invoke_build_dtable (0, args);
10787           func = build_invokevirtual (dtable, method);
10788           break;
10789
10790         case INVOKE_NONVIRTUAL:
10791           /* If the object for the method call is null, we throw an
10792              exception.  We don't do this if the object is the current
10793              method's `this'.  In other cases we just rely on an
10794              optimization pass to eliminate redundant checks.  */
10795           if (TREE_VALUE (args) != current_this)
10796             {
10797               /* We use a save_expr here to make sure we only evaluate
10798                  the new `self' expression once.  */
10799               tree save_arg = save_expr (TREE_VALUE (args));
10800               TREE_VALUE (args) = save_arg;
10801               check = java_check_reference (save_arg, 1);
10802             }
10803           /* Fall through.  */
10804
10805         case INVOKE_SUPER:
10806         case INVOKE_STATIC:
10807           {
10808             tree signature = build_java_signature (TREE_TYPE (method));
10809             func = build_known_method_ref (method, TREE_TYPE (method),
10810                                            DECL_CONTEXT (method),
10811                                            signature, args);
10812           }
10813           break;
10814
10815         case INVOKE_INTERFACE:
10816           dtable = invoke_build_dtable (1, args);
10817           func = build_invokeinterface (dtable, method);
10818           break;
10819
10820         default:
10821           abort ();
10822         }
10823
10824       /* Ensure self_type is initialized, (invokestatic). FIXME */
10825       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10826     }
10827
10828   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10829   TREE_OPERAND (patch, 0) = func;
10830   TREE_OPERAND (patch, 1) = args;
10831   patch = check_for_builtin (method, patch);
10832   original_call = patch;
10833
10834   /* We're processing a `new TYPE ()' form. New is called and its
10835      returned value is the first argument to the constructor. We build
10836      a COMPOUND_EXPR and use saved expression so that the overall NEW
10837      expression value is a pointer to a newly created and initialized
10838      class. */
10839   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10840     {
10841       tree class = DECL_CONTEXT (method);
10842       tree c1, saved_new, size, new;
10843       tree alloc_node;
10844
10845       if (flag_emit_class_files || flag_emit_xref)
10846         {
10847           TREE_TYPE (patch) = build_pointer_type (class);
10848           return patch;
10849         }
10850       if (!TYPE_SIZE (class))
10851         safe_layout_class (class);
10852       size = size_in_bytes (class);
10853       alloc_node =
10854         (class_has_finalize_method (class) ? alloc_object_node
10855                                            : alloc_no_finalizer_node);
10856       new = build (CALL_EXPR, promote_type (class),
10857                    build_address_of (alloc_node),
10858                    tree_cons (NULL_TREE, build_class_ref (class),
10859                               build_tree_list (NULL_TREE,
10860                                                size_in_bytes (class))),
10861                    NULL_TREE);
10862       saved_new = save_expr (new);
10863       c1 = build_tree_list (NULL_TREE, saved_new);
10864       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10865       TREE_OPERAND (original_call, 1) = c1;
10866       TREE_SET_CODE (original_call, CALL_EXPR);
10867       patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10868     }
10869
10870   /* If CHECK is set, then we are building a check to see if the object
10871      is NULL.  */
10872   if (check != NULL_TREE)
10873     {
10874       /* We have to call force_evaluation_order now because creating a
10875          COMPOUND_EXPR wraps the arg list in a way that makes it
10876          unrecognizable by force_evaluation_order later.  Yuk.  */
10877       patch = build (COMPOUND_EXPR, TREE_TYPE (patch), check,
10878                      force_evaluation_order (patch));
10879       TREE_SIDE_EFFECTS (patch) = 1;
10880     }
10881
10882   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
10883      put it as the first expression of a COMPOUND_EXPR. The second
10884      expression being an empty statement to be later patched if
10885      necessary. We remember a TREE_LIST (the PURPOSE is the method,
10886      the VALUE is the compound) in a hashtable and return a
10887      COMPOUND_EXPR built so that the result of the evaluation of the
10888      original PATCH node is returned. */
10889   if (STATIC_CLASS_INIT_OPT_P ()
10890       && current_function_decl && METHOD_STATIC (method))
10891     {
10892       tree list;
10893       tree fndecl = current_function_decl;
10894       /* We have to call force_evaluation_order now because creating a
10895          COMPOUND_EXPR wraps the arg list in a way that makes it
10896          unrecognizable by force_evaluation_order later.  Yuk.  */
10897       tree save = save_expr (force_evaluation_order (patch));
10898       tree type = TREE_TYPE (patch);
10899
10900       patch = build (COMPOUND_EXPR, type, save, empty_stmt_node);
10901       list = tree_cons (method, patch,
10902                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
10903
10904       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
10905
10906       patch = build (COMPOUND_EXPR, type, patch, save);
10907     }
10908
10909   return patch;
10910 }
10911
10912 static int
10913 invocation_mode (tree method, int super)
10914 {
10915   int access = get_access_flags_from_decl (method);
10916
10917   if (super)
10918     return INVOKE_SUPER;
10919
10920   if (access & ACC_STATIC)
10921     return INVOKE_STATIC;
10922
10923   /* We have to look for a constructor before we handle nonvirtual
10924      calls; otherwise the constructor will look nonvirtual.  */
10925   if (DECL_CONSTRUCTOR_P (method))
10926     return INVOKE_STATIC;
10927
10928   if (access & ACC_FINAL || access & ACC_PRIVATE)
10929     return INVOKE_NONVIRTUAL;
10930
10931   if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
10932     return INVOKE_NONVIRTUAL;
10933
10934   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
10935     return INVOKE_INTERFACE;
10936
10937   return INVOKE_VIRTUAL;
10938 }
10939
10940 /* Retrieve a refined list of matching methods. It covers the step
10941    15.11.2 (Compile-Time Step 2) */
10942
10943 static tree
10944 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
10945 {
10946   tree atl = end_params_node;           /* Arg Type List */
10947   tree method, signature, list, node;
10948   const char *candidates;               /* Used for error report */
10949   char *dup;
10950
10951   /* Fix the arguments */
10952   for (node = arg_list; node; node = TREE_CHAIN (node))
10953     {
10954       tree current_arg = TREE_TYPE (TREE_VALUE (node));
10955       /* Non primitive type may have to be resolved */
10956       if (!JPRIMITIVE_TYPE_P (current_arg))
10957         resolve_and_layout (current_arg, NULL_TREE);
10958       /* And promoted */
10959       if (TREE_CODE (current_arg) == RECORD_TYPE)
10960         current_arg = promote_type (current_arg);
10961       atl = tree_cons (NULL_TREE, current_arg, atl);
10962     }
10963
10964   /* Presto. If we're dealing with an anonymous class and a
10965      constructor call, generate the right constructor now, since we
10966      know the arguments' types. */
10967
10968   if (lc && ANONYMOUS_CLASS_P (class))
10969     {
10970       tree saved_current_class;
10971       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
10972       saved_current_class = current_class;
10973       current_class = class;
10974       fix_constructors (mdecl);
10975       current_class = saved_current_class;
10976     }
10977
10978   /* Find all candidates and then refine the list, searching for the
10979      most specific method. */
10980   list = find_applicable_accessible_methods_list (lc, class, name, atl);
10981   list = find_most_specific_methods_list (list);
10982   if (list && !TREE_CHAIN (list))
10983     return TREE_VALUE (list);
10984
10985   /* Issue an error. List candidates if any. Candidates are listed
10986      only if accessible (non accessible methods may end-up here for
10987      the sake of a better error report). */
10988   candidates = NULL;
10989   if (list)
10990     {
10991       tree current;
10992       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
10993       for (current = list; current; current = TREE_CHAIN (current))
10994         {
10995           tree cm = TREE_VALUE (current);
10996           char string [4096];
10997           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
10998             continue;
10999           sprintf
11000             (string, "  `%s' in `%s'%s",
11001              get_printable_method_name (cm),
11002              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
11003              (TREE_CHAIN (current) ? "\n" : ""));
11004           obstack_grow (&temporary_obstack, string, strlen (string));
11005         }
11006       obstack_1grow (&temporary_obstack, '\0');
11007       candidates = obstack_finish (&temporary_obstack);
11008     }
11009   /* Issue the error message */
11010   method = make_node (FUNCTION_TYPE);
11011   TYPE_ARG_TYPES (method) = atl;
11012   signature = build_java_argument_signature (method);
11013   dup = xstrdup (lang_printable_name (class, 0));
11014   parse_error_context (cl, "Can't find %s `%s(%s)' in type `%s'%s",
11015                        (lc ? "constructor" : "method"),
11016                        (lc ? dup : IDENTIFIER_POINTER (name)),
11017                        IDENTIFIER_POINTER (signature), dup,
11018                        (candidates ? candidates : ""));
11019   free (dup);
11020   return NULL_TREE;
11021 }
11022
11023 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
11024    when we're looking for a constructor. */
11025
11026 static tree
11027 find_applicable_accessible_methods_list (int lc, tree class, tree name,
11028                                          tree arglist)
11029 {
11030   static htab_t searched_classes;
11031   static int search_not_done = 0;
11032   tree list = NULL_TREE, all_list = NULL_TREE;
11033
11034   /* Check the hash table to determine if this class has been searched
11035      already. */
11036   if (searched_classes)
11037     {
11038       if (htab_find (searched_classes, class) != NULL)
11039         return NULL;
11040     }
11041   else
11042     {
11043       searched_classes = htab_create (10, htab_hash_pointer,
11044                                       htab_eq_pointer, NULL);
11045     }
11046
11047   search_not_done++;
11048   *htab_find_slot (searched_classes, class, INSERT) = class;
11049
11050   if (!CLASS_LOADED_P (class) && !CLASS_FROM_SOURCE_P (class))
11051     {
11052       load_class (class, 1);
11053       safe_layout_class (class);
11054     }
11055
11056   /* Search interfaces */
11057   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11058       && CLASS_INTERFACE (TYPE_NAME (class)))
11059     {
11060       int i, n;
11061       tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11062       search_applicable_methods_list (lc, TYPE_METHODS (class),
11063                                       name, arglist, &list, &all_list);
11064       n = TREE_VEC_LENGTH (basetype_vec);
11065       for (i = 1; i < n; i++)
11066         {
11067           tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11068           tree rlist;
11069
11070           rlist = find_applicable_accessible_methods_list (lc,  t, name,
11071                                                            arglist);
11072           list = chainon (rlist, list);
11073         }
11074     }
11075   /* Search classes */
11076   else
11077     {
11078       search_applicable_methods_list (lc, TYPE_METHODS (class),
11079                                       name, arglist, &list, &all_list);
11080
11081       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11082          that we only search in class. Note that we should have found
11083          something at this point. */
11084       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11085         {
11086           lc = 1;
11087           if (!list)
11088             abort ();
11089         }
11090
11091       /* We must search all interfaces of this class */
11092       if (!lc)
11093       {
11094         tree basetype_vec = TYPE_BINFO_BASETYPES (class);
11095         int n = TREE_VEC_LENGTH (basetype_vec), i;
11096         for (i = 1; i < n; i++)
11097           {
11098             tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
11099             if (t != object_type_node)
11100               {
11101                 tree rlist
11102                   = find_applicable_accessible_methods_list (lc, t,
11103                                                              name, arglist);
11104                 list = chainon (rlist, list);
11105               }
11106           }
11107       }
11108
11109       /* Search superclass */
11110       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11111         {
11112           tree rlist;
11113           class = CLASSTYPE_SUPER (class);
11114           rlist = find_applicable_accessible_methods_list (lc, class,
11115                                                            name, arglist);
11116           list = chainon (rlist, list);
11117         }
11118     }
11119
11120   search_not_done--;
11121
11122   /* We're done. Reset the searched classes list and finally search
11123      java.lang.Object if it wasn't searched already. */
11124   if (!search_not_done)
11125     {
11126       if (!lc
11127           && TYPE_METHODS (object_type_node)
11128           && htab_find (searched_classes, object_type_node) == NULL)
11129         {
11130           search_applicable_methods_list (lc,
11131                                           TYPE_METHODS (object_type_node),
11132                                           name, arglist, &list, &all_list);
11133         }
11134       htab_delete (searched_classes);
11135       searched_classes = NULL;
11136     }
11137
11138   /* Either return the list obtained or all selected (but
11139      inaccessible) methods for better error report. */
11140   return (!list ? all_list : list);
11141 }
11142
11143 /* Effectively search for the appropriate method in method */
11144
11145 static void
11146 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11147                                 tree *list, tree *all_list)
11148 {
11149   for (; method; method = TREE_CHAIN (method))
11150     {
11151       /* When dealing with constructor, stop here, otherwise search
11152          other classes */
11153       if (lc && !DECL_CONSTRUCTOR_P (method))
11154         continue;
11155       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11156                        || (DECL_NAME (method) != name)))
11157         continue;
11158
11159       if (argument_types_convertible (method, arglist))
11160         {
11161           /* Retain accessible methods only */
11162           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11163                                  method, NULL_TREE, 0))
11164             *list = tree_cons (NULL_TREE, method, *list);
11165           else
11166             /* Also retain all selected method here */
11167             *all_list = tree_cons (NULL_TREE, method, *list);
11168         }
11169     }
11170 }
11171
11172 /* 15.11.2.2 Choose the Most Specific Method */
11173
11174 static tree
11175 find_most_specific_methods_list (tree list)
11176 {
11177   int max = 0;
11178   int abstract, candidates;
11179   tree current, new_list = NULL_TREE;
11180   for (current = list; current; current = TREE_CHAIN (current))
11181     {
11182       tree method;
11183       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11184
11185       for (method = list; method; method = TREE_CHAIN (method))
11186         {
11187           tree method_v, current_v;
11188           /* Don't test a method against itself */
11189           if (method == current)
11190             continue;
11191
11192           method_v = TREE_VALUE (method);
11193           current_v = TREE_VALUE (current);
11194
11195           /* Compare arguments and location where methods where declared */
11196           if (argument_types_convertible (method_v, current_v))
11197             {
11198               if (valid_method_invocation_conversion_p
11199                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11200                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11201                       && enclosing_context_p (DECL_CONTEXT (method_v),
11202                                               DECL_CONTEXT (current_v))))
11203                 {
11204                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
11205                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11206                   max = (v > max ? v : max);
11207                 }
11208             }
11209         }
11210     }
11211
11212   /* Review the list and select the maximally specific methods */
11213   for (current = list, abstract = -1, candidates = -1;
11214        current; current = TREE_CHAIN (current))
11215     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11216       {
11217         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11218         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11219         candidates++;
11220       }
11221
11222   /* If we have several and they're all abstract, just pick the
11223      closest one. */
11224   if (candidates > 0 && candidates == abstract)
11225     {
11226       /* FIXME: merge the throws clauses.  There is no convenient way
11227          to do this in gcj right now, since ideally we'd like to
11228          introduce a new METHOD_DECL here, but that is really not
11229          possible.  */
11230       new_list = nreverse (new_list);
11231       TREE_CHAIN (new_list) = NULL_TREE;
11232       return new_list;
11233     }
11234
11235   /* We have several (we couldn't find a most specific), all but one
11236      are abstract, we pick the only non abstract one. */
11237   if (candidates > 0 && (candidates == abstract+1))
11238     {
11239       for (current = new_list; current; current = TREE_CHAIN (current))
11240         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11241           {
11242             TREE_CHAIN (current) = NULL_TREE;
11243             new_list = current;
11244           }
11245     }
11246
11247   /* If we can't find one, lower expectations and try to gather multiple
11248      maximally specific methods */
11249   while (!new_list && max)
11250     {
11251       while (--max > 0)
11252         {
11253           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11254             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11255         }
11256     }
11257
11258   return new_list;
11259 }
11260
11261 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11262    converted by method invocation conversion (5.3) to the type of the
11263    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11264    to change less often than M1. */
11265
11266 static GTY(()) tree m2_arg_value;
11267 static GTY(()) tree m2_arg_cache;
11268
11269 static int
11270 argument_types_convertible (tree m1, tree m2_or_arglist)
11271 {
11272   tree m1_arg, m2_arg;
11273
11274   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11275
11276   if (m2_arg_value == m2_or_arglist)
11277     m2_arg = m2_arg_cache;
11278   else
11279     {
11280       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11281          argument types */
11282       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11283         {
11284           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11285           if (!METHOD_STATIC (m2_or_arglist))
11286             m2_arg = TREE_CHAIN (m2_arg);
11287         }
11288       else
11289         m2_arg = m2_or_arglist;
11290
11291       m2_arg_value = m2_or_arglist;
11292       m2_arg_cache = m2_arg;
11293     }
11294
11295   while (m1_arg != end_params_node && m2_arg != end_params_node)
11296     {
11297       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11298       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11299                                                  TREE_VALUE (m2_arg)))
11300         break;
11301       m1_arg = TREE_CHAIN (m1_arg);
11302       m2_arg = TREE_CHAIN (m2_arg);
11303     }
11304   return m1_arg == end_params_node && m2_arg == end_params_node;
11305 }
11306
11307 /* Qualification routines */
11308
11309 /* Given a name x.y.z, look up x locally.  If it's found, save the
11310    decl.  If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11311    so that we later try and load the appropriate classes.  */
11312 static void
11313 qualify_ambiguous_name (tree id)
11314 {
11315   tree name, decl;
11316
11317   /* We inspect the first item of the qualification list.  As a sanity
11318      check, make sure that it is an identfier node.  */
11319   tree qual = EXPR_WFL_QUALIFICATION (id);
11320   tree qual_wfl = QUAL_WFL (qual);
11321
11322   if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11323     return;
11324
11325   name = EXPR_WFL_NODE (qual_wfl);
11326
11327   /* If we don't have an identifier, or we have a 'this' or 'super',
11328      then field access processing is all we need : there is nothing
11329      for us to do.  */
11330   if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11331       name == this_identifier_node ||
11332       name == super_identifier_node)
11333     return;
11334
11335   /* If name appears within the scope of a local variable declaration
11336      or parameter declaration, or is a field within an enclosing
11337      class, then it is an expression name.  Save the decl and let
11338      resolve_field_access do it's work.  */
11339   if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11340       (decl = lookup_field_wrapper (current_class, name)))
11341     {
11342       QUAL_RESOLUTION (qual) = decl;
11343       return;
11344     }
11345
11346   /* If name is a known class name (either declared or imported), mark
11347      us as a type name.  */
11348   if ((decl = resolve_and_layout (name, NULL_TREE)))
11349     {
11350       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11351       QUAL_RESOLUTION (qual) = decl;
11352     }
11353
11354   /* Check here that NAME isn't declared by more than one
11355      type-import-on-demand declaration of the compilation unit
11356      containing NAME. FIXME */
11357
11358   /* We couldn't find a declaration for the name.  Assume for now that
11359      we have a qualified class name that needs to be loaded from an
11360      external class file.  */
11361   else
11362     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11363
11364   /* Propagate the qualification across other components of the
11365      qualified name */
11366   for (qual = TREE_CHAIN (qual); qual;
11367        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11368     {
11369       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11370         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11371     }
11372
11373   /* Store the global qualification for the ambiguous part of ID back
11374      into ID fields */
11375   if (RESOLVE_TYPE_NAME_P (qual_wfl))
11376     RESOLVE_TYPE_NAME_P (id) = 1;
11377   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11378     RESOLVE_PACKAGE_NAME_P (id) = 1;
11379 }
11380
11381 static int
11382 breakdown_qualified (tree *left, tree *right, tree source)
11383 {
11384   char *p, *base;
11385   int l = IDENTIFIER_LENGTH (source);
11386
11387   base = alloca (l + 1);
11388   memcpy (base, IDENTIFIER_POINTER (source), l + 1);
11389
11390   /* Breakdown NAME into REMAINDER . IDENTIFIER.  */
11391   p = base + l - 1;
11392   while (*p != '.' && p != base)
11393     p--;
11394
11395   /* We didn't find a '.'. Return an error.  */
11396   if (p == base)
11397     return 1;
11398
11399   *p = '\0';
11400   if (right)
11401     *right = get_identifier (p+1);
11402   *left = get_identifier (base);
11403
11404   return 0;
11405 }
11406
11407 /* Return TRUE if two classes are from the same package. */
11408
11409 static int
11410 in_same_package (tree name1, tree name2)
11411 {
11412   tree tmp;
11413   tree pkg1;
11414   tree pkg2;
11415
11416   if (TREE_CODE (name1) == TYPE_DECL)
11417     name1 = DECL_NAME (name1);
11418   if (TREE_CODE (name2) == TYPE_DECL)
11419     name2 = DECL_NAME (name2);
11420
11421   if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
11422     /* One in empty package. */
11423     return 0;
11424
11425   if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
11426     /* Both in empty package. */
11427     return 1;
11428
11429   breakdown_qualified (&pkg1, &tmp, name1);
11430   breakdown_qualified (&pkg2, &tmp, name2);
11431
11432   return (pkg1 == pkg2);
11433 }
11434
11435 /* Patch tree nodes in a function body. When a BLOCK is found, push
11436    local variable decls if present.
11437    Same as java_complete_lhs, but does resolve static finals to values. */
11438
11439 static tree
11440 java_complete_tree (tree node)
11441 {
11442   node = java_complete_lhs (node);
11443   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11444       && DECL_INITIAL (node) != NULL_TREE
11445       && !flag_emit_xref)
11446     {
11447       tree value = fold_constant_for_init (node, node);
11448       if (value != NULL_TREE)
11449         return value;
11450     }
11451   return node;
11452 }
11453
11454 static tree
11455 java_stabilize_reference (tree node)
11456 {
11457   if (TREE_CODE (node) == COMPOUND_EXPR)
11458     {
11459       tree op0 = TREE_OPERAND (node, 0);
11460       tree op1 = TREE_OPERAND (node, 1);
11461       TREE_OPERAND (node, 0) = save_expr (op0);
11462       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11463       return node;
11464     }
11465   return stabilize_reference (node);
11466 }
11467
11468 /* Patch tree nodes in a function body. When a BLOCK is found, push
11469    local variable decls if present.
11470    Same as java_complete_tree, but does not resolve static finals to values. */
11471
11472 static tree
11473 java_complete_lhs (tree node)
11474 {
11475   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11476   int flag;
11477
11478   /* CONVERT_EXPR always has its type set, even though it needs to be
11479      worked out. */
11480   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11481     return node;
11482
11483   /* The switch block implements cases processing container nodes
11484      first.  Contained nodes are always written back. Leaves come
11485      next and return a value. */
11486   switch (TREE_CODE (node))
11487     {
11488     case BLOCK:
11489
11490       /* 1- Block section.
11491          Set the local values on decl names so we can identify them
11492          faster when they're referenced. At that stage, identifiers
11493          are legal so we don't check for declaration errors. */
11494       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11495         {
11496           DECL_CONTEXT (cn) = current_function_decl;
11497           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11498         }
11499       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11500           CAN_COMPLETE_NORMALLY (node) = 1;
11501       else
11502         {
11503           tree stmt = BLOCK_EXPR_BODY (node);
11504           tree *ptr;
11505           int error_seen = 0;
11506           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11507             {
11508               /* Re-order from (((A; B); C); ...; Z) to
11509                  (A; (B; (C ; (...; Z)))).
11510                  This makes it easier to scan the statements left-to-right
11511                  without using recursion (which might overflow the stack
11512                  if the block has many statements. */
11513               for (;;)
11514                 {
11515                   tree left = TREE_OPERAND (stmt, 0);
11516                   if (TREE_CODE (left) != COMPOUND_EXPR)
11517                     break;
11518                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11519                   TREE_OPERAND (left, 1) = stmt;
11520                   stmt = left;
11521                 }
11522               BLOCK_EXPR_BODY (node) = stmt;
11523             }
11524
11525           /* Now do the actual complete, without deep recursion for
11526              long blocks. */
11527           ptr = &BLOCK_EXPR_BODY (node);
11528           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11529                  && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
11530             {
11531               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11532               tree *next = &TREE_OPERAND (*ptr, 1);
11533               TREE_OPERAND (*ptr, 0) = cur;
11534               if (cur == empty_stmt_node)
11535                 {
11536                   /* Optimization;  makes it easier to detect empty bodies.
11537                      Most useful for <clinit> with all-constant initializer. */
11538                   *ptr = *next;
11539                   continue;
11540                 }
11541               if (TREE_CODE (cur) == ERROR_MARK)
11542                 error_seen++;
11543               else if (! CAN_COMPLETE_NORMALLY (cur))
11544                 {
11545                   wfl_op2 = *next;
11546                   for (;;)
11547                     {
11548                       if (TREE_CODE (wfl_op2) == BLOCK)
11549                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11550                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11551                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11552                       else
11553                         break;
11554                     }
11555                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11556                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11557                     unreachable_stmt_error (*ptr);
11558                 }
11559               if (TREE_TYPE (*ptr) == NULL_TREE)
11560                 TREE_TYPE (*ptr) = void_type_node;
11561               ptr = next;
11562             }
11563           *ptr = java_complete_tree (*ptr);
11564
11565           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11566             return error_mark_node;
11567           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11568         }
11569       /* Turn local bindings to null */
11570       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11571         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11572
11573       TREE_TYPE (node) = void_type_node;
11574       break;
11575
11576       /* 2- They are expressions but ultimately deal with statements */
11577
11578     case THROW_EXPR:
11579       wfl_op1 = TREE_OPERAND (node, 0);
11580       COMPLETE_CHECK_OP_0 (node);
11581       /* 14.19 A throw statement cannot complete normally. */
11582       CAN_COMPLETE_NORMALLY (node) = 0;
11583       return patch_throw_statement (node, wfl_op1);
11584
11585     case SYNCHRONIZED_EXPR:
11586       wfl_op1 = TREE_OPERAND (node, 0);
11587       return patch_synchronized_statement (node, wfl_op1);
11588
11589     case TRY_EXPR:
11590       return patch_try_statement (node);
11591
11592     case TRY_FINALLY_EXPR:
11593       COMPLETE_CHECK_OP_0 (node);
11594       COMPLETE_CHECK_OP_1 (node);
11595       /* Reduce try/finally nodes with an empty try block.  */
11596       if (TREE_OPERAND (node, 0) == empty_stmt_node
11597           || BLOCK_EMPTY_P (TREE_OPERAND (node, 0)))
11598         return TREE_OPERAND (node, 1);
11599       /* Likewise for an empty finally block.  */
11600       if (TREE_OPERAND (node, 1) == empty_stmt_node
11601           || BLOCK_EMPTY_P (TREE_OPERAND (node, 1)))
11602         return TREE_OPERAND (node, 0);
11603       CAN_COMPLETE_NORMALLY (node)
11604         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11605            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11606       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11607       return node;
11608
11609     case LABELED_BLOCK_EXPR:
11610       PUSH_LABELED_BLOCK (node);
11611       if (LABELED_BLOCK_BODY (node))
11612         COMPLETE_CHECK_OP_1 (node);
11613       TREE_TYPE (node) = void_type_node;
11614       POP_LABELED_BLOCK ();
11615
11616       if (LABELED_BLOCK_BODY (node) == empty_stmt_node)
11617         {
11618           LABELED_BLOCK_BODY (node) = NULL_TREE;
11619           CAN_COMPLETE_NORMALLY (node) = 1;
11620         }
11621       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11622         CAN_COMPLETE_NORMALLY (node) = 1;
11623       return node;
11624
11625     case EXIT_BLOCK_EXPR:
11626       /* We don't complete operand 1, because it's the return value of
11627          the EXIT_BLOCK_EXPR which doesn't exist it Java */
11628       return patch_bc_statement (node);
11629
11630     case CASE_EXPR:
11631       cn = java_complete_tree (TREE_OPERAND (node, 0));
11632       if (cn == error_mark_node)
11633         return cn;
11634
11635       /* First, the case expression must be constant. Values of final
11636          fields are accepted. */
11637       cn = fold (cn);
11638       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11639           && JDECL_P (TREE_OPERAND (cn, 1))
11640           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11641           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11642         {
11643           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11644                                        TREE_OPERAND (cn, 1));
11645         }
11646       /* Accept final locals too. */
11647       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn))
11648         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11649
11650       if (!TREE_CONSTANT (cn) && !flag_emit_xref)
11651         {
11652           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11653           parse_error_context (node, "Constant expression required");
11654           return error_mark_node;
11655         }
11656
11657       nn = ctxp->current_loop;
11658
11659       /* It must be assignable to the type of the switch expression. */
11660       if (!try_builtin_assignconv (NULL_TREE,
11661                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11662         {
11663           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11664           parse_error_context
11665             (wfl_operator,
11666              "Incompatible type for case. Can't convert `%s' to `int'",
11667              lang_printable_name (TREE_TYPE (cn), 0));
11668           return error_mark_node;
11669         }
11670
11671       cn = fold (convert (int_type_node, cn));
11672       TREE_CONSTANT_OVERFLOW (cn) = 0;
11673       CAN_COMPLETE_NORMALLY (cn) = 1;
11674
11675       /* Save the label on a list so that we can later check for
11676          duplicates.  */
11677       case_label_list = tree_cons (node, cn, case_label_list);
11678
11679       /* Multiple instance of a case label bearing the same value is
11680          checked later. The case expression is all right so far. */
11681       if (TREE_CODE (cn) == VAR_DECL)
11682         cn = DECL_INITIAL (cn);
11683       TREE_OPERAND (node, 0) = cn;
11684       TREE_TYPE (node) = void_type_node;
11685       CAN_COMPLETE_NORMALLY (node) = 1;
11686       TREE_SIDE_EFFECTS (node) = 1;
11687       break;
11688
11689     case DEFAULT_EXPR:
11690       nn = ctxp->current_loop;
11691       /* Only one default label is allowed per switch statement */
11692       if (SWITCH_HAS_DEFAULT (nn))
11693         {
11694           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11695           parse_error_context (wfl_operator,
11696                                "Duplicate case label: `default'");
11697           return error_mark_node;
11698         }
11699       else
11700         SWITCH_HAS_DEFAULT (nn) = 1;
11701       TREE_TYPE (node) = void_type_node;
11702       TREE_SIDE_EFFECTS (node) = 1;
11703       CAN_COMPLETE_NORMALLY (node) = 1;
11704       break;
11705
11706     case SWITCH_EXPR:
11707     case LOOP_EXPR:
11708       PUSH_LOOP (node);
11709       /* Check whether the loop was enclosed in a labeled
11710          statement. If not, create one, insert the loop in it and
11711          return the node */
11712       nn = patch_loop_statement (node);
11713
11714       /* Anyways, walk the body of the loop */
11715       if (TREE_CODE (node) == LOOP_EXPR)
11716         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11717       /* Switch statement: walk the switch expression and the cases */
11718       else
11719         node = patch_switch_statement (node);
11720
11721       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11722         nn = error_mark_node;
11723       else
11724         {
11725           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11726           /* If we returned something different, that's because we
11727              inserted a label. Pop the label too. */
11728           if (nn != node)
11729             {
11730               if (CAN_COMPLETE_NORMALLY (node))
11731                 CAN_COMPLETE_NORMALLY (nn) = 1;
11732               POP_LABELED_BLOCK ();
11733             }
11734         }
11735       POP_LOOP ();
11736       return nn;
11737
11738     case EXIT_EXPR:
11739       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11740       return patch_exit_expr (node);
11741
11742     case COND_EXPR:
11743       /* Condition */
11744       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11745       if (TREE_OPERAND (node, 0) == error_mark_node)
11746         return error_mark_node;
11747       /* then-else branches */
11748       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11749       if (TREE_OPERAND (node, 1) == error_mark_node)
11750         return error_mark_node;
11751       TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11752       if (TREE_OPERAND (node, 2) == error_mark_node)
11753         return error_mark_node;
11754       return patch_if_else_statement (node);
11755       break;
11756
11757     case CONDITIONAL_EXPR:
11758       /* Condition */
11759       wfl_op1 = TREE_OPERAND (node, 0);
11760       COMPLETE_CHECK_OP_0 (node);
11761       wfl_op2 = TREE_OPERAND (node, 1);
11762       COMPLETE_CHECK_OP_1 (node);
11763       wfl_op3 = TREE_OPERAND (node, 2);
11764       COMPLETE_CHECK_OP_2 (node);
11765       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11766
11767       /* 3- Expression section */
11768     case COMPOUND_EXPR:
11769       wfl_op2 = TREE_OPERAND (node, 1);
11770       TREE_OPERAND (node, 0) = nn =
11771         java_complete_tree (TREE_OPERAND (node, 0));
11772       if (wfl_op2 == empty_stmt_node)
11773         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11774       else
11775         {
11776           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11777             {
11778               /* An unreachable condition in a do-while statement
11779                  is *not* (technically) an unreachable statement. */
11780               nn = wfl_op2;
11781               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11782                 nn = EXPR_WFL_NODE (nn);
11783               /* NN can be NULL_TREE exactly when UPDATE is, in
11784                  finish_for_loop.  */
11785               if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11786                 {
11787                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11788                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11789                     {
11790                       /* Perhaps this warning should have an
11791                          associated flag.  The code being compiled is
11792                          pedantically correct, but useless.  */
11793                       parse_warning_context (wfl_operator,
11794                                              "Unreachable statement");
11795                     }
11796                   else
11797                     parse_error_context (wfl_operator,
11798                                          "Unreachable statement");
11799                 }
11800             }
11801           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11802           if (TREE_OPERAND (node, 1) == error_mark_node)
11803             return error_mark_node;
11804           /* Even though we might allow the case where the first
11805              operand doesn't return normally, we still should compute
11806              CAN_COMPLETE_NORMALLY correctly.  */
11807           CAN_COMPLETE_NORMALLY (node)
11808             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11809                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11810         }
11811       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11812       break;
11813
11814     case RETURN_EXPR:
11815       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11816       return patch_return (node);
11817
11818     case EXPR_WITH_FILE_LOCATION:
11819       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11820           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11821         {
11822           tree wfl = node;
11823           node = resolve_expression_name (node, NULL);
11824           if (node == error_mark_node)
11825             return node;
11826           /* Keep line number information somewhere were it doesn't
11827              disrupt the completion process. */
11828           if (flag_emit_xref && TREE_CODE (node) != CALL_EXPR)
11829             {
11830               EXPR_WFL_NODE (wfl) = TREE_OPERAND (node, 1);
11831               TREE_OPERAND (node, 1) = wfl;
11832             }
11833           CAN_COMPLETE_NORMALLY (node) = 1;
11834         }
11835       else
11836         {
11837           tree body;
11838           int save_lineno = input_line;
11839           input_line = EXPR_WFL_LINENO (node);
11840           body = java_complete_tree (EXPR_WFL_NODE (node));
11841           input_line = save_lineno;
11842           EXPR_WFL_NODE (node) = body;
11843           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11844           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11845           if (body == empty_stmt_node || TREE_CONSTANT (body))
11846             {
11847               /* Makes it easier to constant fold, detect empty bodies. */
11848               return body;
11849             }
11850           if (body == error_mark_node)
11851             {
11852               /* Its important for the evaluation of assignment that
11853                  this mark on the TREE_TYPE is propagated. */
11854               TREE_TYPE (node) = error_mark_node;
11855               return error_mark_node;
11856             }
11857           else
11858             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11859
11860         }
11861       break;
11862
11863     case NEW_ARRAY_EXPR:
11864       /* Patch all the dimensions */
11865       flag = 0;
11866       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11867         {
11868           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11869           tree dim = convert (int_type_node,
11870                               java_complete_tree (TREE_VALUE (cn)));
11871           if (dim == error_mark_node)
11872             {
11873               flag = 1;
11874               continue;
11875             }
11876           else
11877             {
11878               TREE_VALUE (cn) = dim;
11879               /* Setup the location of the current dimension, for
11880                  later error report. */
11881               TREE_PURPOSE (cn) =
11882                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11883               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11884             }
11885         }
11886       /* They complete the array creation expression, if no errors
11887          were found. */
11888       CAN_COMPLETE_NORMALLY (node) = 1;
11889       return (flag ? error_mark_node
11890               : force_evaluation_order (patch_newarray (node)));
11891
11892     case NEW_ANONYMOUS_ARRAY_EXPR:
11893       /* Create the array type if necessary. */
11894       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11895         {
11896           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11897           if (!(type = resolve_type_during_patch (type)))
11898             return error_mark_node;
11899           type = build_array_from_name (type, NULL_TREE,
11900                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11901           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11902         }
11903       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11904                                    ANONYMOUS_ARRAY_INITIALIZER (node));
11905       if (node == error_mark_node)
11906         return error_mark_node;
11907       CAN_COMPLETE_NORMALLY (node) = 1;
11908       return node;
11909
11910     case NEW_CLASS_EXPR:
11911     case CALL_EXPR:
11912       /* Complete function's argument(s) first */
11913       if (complete_function_arguments (node))
11914         return error_mark_node;
11915       else
11916         {
11917           tree decl, wfl = TREE_OPERAND (node, 0);
11918           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
11919           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
11920                            super_identifier_node);
11921           tree arguments;
11922           int location = EXPR_WFL_LINECOL (node);
11923
11924           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
11925                                           from_super, 0, &decl);
11926           if (node == error_mark_node)
11927             return error_mark_node;
11928
11929           if (TREE_CODE (node) == CALL_EXPR
11930               && TREE_OPERAND (node, 1) != NULL_TREE)
11931             arguments = TREE_VALUE (TREE_OPERAND (node, 1));
11932           else
11933             arguments = NULL_TREE;
11934           check_thrown_exceptions (location, decl, arguments);
11935           /* If we call this(...), register signature and positions */
11936           if (in_this)
11937             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
11938               tree_cons (wfl, decl,
11939                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
11940           CAN_COMPLETE_NORMALLY (node) = 1;
11941           return force_evaluation_order (node);
11942         }
11943
11944     case MODIFY_EXPR:
11945       /* Save potential wfls */
11946       wfl_op1 = TREE_OPERAND (node, 0);
11947       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
11948
11949       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
11950           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
11951           && DECL_INITIAL (nn) != NULL_TREE)
11952         {
11953           tree value;
11954
11955           value = fold_constant_for_init (nn, nn);
11956
11957           /* When we have a primitype type, or a string and we're not
11958              emitting a class file, we actually don't want to generate
11959              anything for the assignment. */
11960           if (value != NULL_TREE &&
11961               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
11962                (TREE_TYPE (value) == string_ptr_type_node &&
11963                 ! flag_emit_class_files)))
11964             {
11965               /* Prepare node for patch_assignment */
11966               TREE_OPERAND (node, 1) = value;
11967               /* Call patch assignment to verify the assignment */
11968               if (patch_assignment (node, wfl_op1) == error_mark_node)
11969                 return error_mark_node;
11970               /* Set DECL_INITIAL properly (a conversion might have
11971                  been decided by patch_assignment) and return the
11972                  empty statement. */
11973               else
11974                 {
11975                   tree patched = patch_string (TREE_OPERAND (node, 1));
11976                   if (patched)
11977                     DECL_INITIAL (nn) = patched;
11978                   else
11979                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
11980                   DECL_FIELD_FINAL_IUD (nn) = 1;
11981                   return empty_stmt_node;
11982                 }
11983             }
11984           if (! flag_emit_class_files)
11985             DECL_INITIAL (nn) = NULL_TREE;
11986         }
11987       wfl_op2 = TREE_OPERAND (node, 1);
11988
11989       if (TREE_OPERAND (node, 0) == error_mark_node)
11990         return error_mark_node;
11991
11992       flag = COMPOUND_ASSIGN_P (wfl_op2);
11993       if (flag)
11994         {
11995           /* This might break when accessing outer field from inner
11996              class. TESTME, FIXME */
11997           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
11998
11999           /* Hand stabilize the lhs on both places */
12000           TREE_OPERAND (node, 0) = lvalue;
12001           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
12002             (flag_emit_class_files ? lvalue : save_expr (lvalue));
12003
12004           /* 15.25.2.a: Left hand is not an array access. FIXME */
12005           /* Now complete the RHS. We write it back later on. */
12006           nn = java_complete_tree (TREE_OPERAND (node, 1));
12007
12008           if ((cn = patch_string (nn)))
12009             nn = cn;
12010
12011           /* The last part of the rewrite for E1 op= E2 is to have
12012              E1 = (T)(E1 op E2), with T being the type of E1. */
12013           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
12014                                                TREE_TYPE (lvalue), nn));
12015
12016           /* If the assignment is compound and has reference type,
12017              then ensure the LHS has type String and nothing else.  */
12018           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
12019               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
12020             parse_error_context (wfl_op2,
12021                                  "Incompatible type for `+='. Can't convert `%s' to `java.lang.String'",
12022                                  lang_printable_name (TREE_TYPE (lvalue), 0));
12023
12024           /* 15.25.2.b: Left hand is an array access. FIXME */
12025         }
12026
12027       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12028          function to complete this RHS. Note that a NEW_ARRAY_INIT
12029          might have been already fully expanded if created as a result
12030          of processing an anonymous array initializer. We avoid doing
12031          the operation twice by testing whether the node already bears
12032          a type. */
12033       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12034         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12035                                    TREE_OPERAND (node, 1));
12036       /* Otherwise we simply complete the RHS */
12037       else
12038         nn = java_complete_tree (TREE_OPERAND (node, 1));
12039
12040       if (nn == error_mark_node)
12041         return error_mark_node;
12042
12043       /* Write back the RHS as we evaluated it. */
12044       TREE_OPERAND (node, 1) = nn;
12045
12046       /* In case we're handling = with a String as a RHS, we need to
12047          produce a String out of the RHS (it might still be a
12048          STRING_CST or a StringBuffer at this stage */
12049       if ((nn = patch_string (TREE_OPERAND (node, 1))))
12050         TREE_OPERAND (node, 1) = nn;
12051
12052       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12053                                         TREE_OPERAND (node, 1))))
12054         {
12055           /* We return error_mark_node if outer_field_access_fix
12056              detects we write into a final. */
12057           if (nn == error_mark_node)
12058             return error_mark_node;
12059           node = nn;
12060         }
12061       else
12062         {
12063           node = patch_assignment (node, wfl_op1);
12064           if (node == error_mark_node)
12065             return error_mark_node;
12066           /* Reorganize the tree if necessary. */
12067           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12068                        || JSTRING_P (TREE_TYPE (node))))
12069             node = java_refold (node);
12070         }
12071
12072       /* Seek to set DECL_INITIAL to a proper value, since it might have
12073          undergone a conversion in patch_assignment. We do that only when
12074          it's necessary to have DECL_INITIAL properly set. */
12075       nn = TREE_OPERAND (node, 0);
12076       if (TREE_CODE (nn) == VAR_DECL
12077           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12078           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12079           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12080               || TREE_TYPE (nn) == string_ptr_type_node))
12081         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12082
12083       CAN_COMPLETE_NORMALLY (node) = 1;
12084       return node;
12085
12086     case MULT_EXPR:
12087     case PLUS_EXPR:
12088     case MINUS_EXPR:
12089     case LSHIFT_EXPR:
12090     case RSHIFT_EXPR:
12091     case URSHIFT_EXPR:
12092     case BIT_AND_EXPR:
12093     case BIT_XOR_EXPR:
12094     case BIT_IOR_EXPR:
12095     case TRUNC_MOD_EXPR:
12096     case TRUNC_DIV_EXPR:
12097     case RDIV_EXPR:
12098     case TRUTH_ANDIF_EXPR:
12099     case TRUTH_ORIF_EXPR:
12100     case EQ_EXPR:
12101     case NE_EXPR:
12102     case GT_EXPR:
12103     case GE_EXPR:
12104     case LT_EXPR:
12105     case LE_EXPR:
12106       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12107          knows how to handle those cases. */
12108       wfl_op1 = TREE_OPERAND (node, 0);
12109       wfl_op2 = TREE_OPERAND (node, 1);
12110
12111       CAN_COMPLETE_NORMALLY (node) = 1;
12112       /* Don't complete string nodes if dealing with the PLUS operand. */
12113       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12114         {
12115           nn = java_complete_tree (wfl_op1);
12116           if (nn == error_mark_node)
12117             return error_mark_node;
12118
12119           TREE_OPERAND (node, 0) = nn;
12120         }
12121       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12122         {
12123           nn = java_complete_tree (wfl_op2);
12124           if (nn == error_mark_node)
12125             return error_mark_node;
12126
12127           TREE_OPERAND (node, 1) = nn;
12128         }
12129       return patch_binop (node, wfl_op1, wfl_op2);
12130
12131     case INSTANCEOF_EXPR:
12132       wfl_op1 = TREE_OPERAND (node, 0);
12133       COMPLETE_CHECK_OP_0 (node);
12134       if (flag_emit_xref)
12135         {
12136           TREE_TYPE (node) = boolean_type_node;
12137           return node;
12138         }
12139       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12140
12141     case UNARY_PLUS_EXPR:
12142     case NEGATE_EXPR:
12143     case TRUTH_NOT_EXPR:
12144     case BIT_NOT_EXPR:
12145     case PREDECREMENT_EXPR:
12146     case PREINCREMENT_EXPR:
12147     case POSTDECREMENT_EXPR:
12148     case POSTINCREMENT_EXPR:
12149     case CONVERT_EXPR:
12150       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12151          how to handle those cases. */
12152       wfl_op1 = TREE_OPERAND (node, 0);
12153       CAN_COMPLETE_NORMALLY (node) = 1;
12154       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12155       if (TREE_OPERAND (node, 0) == error_mark_node)
12156         return error_mark_node;
12157       node = patch_unaryop (node, wfl_op1);
12158       CAN_COMPLETE_NORMALLY (node) = 1;
12159       break;
12160
12161     case ARRAY_REF:
12162       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12163          how to handle those cases. */
12164       wfl_op1 = TREE_OPERAND (node, 0);
12165       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12166       if (TREE_OPERAND (node, 0) == error_mark_node)
12167         return error_mark_node;
12168       if (!flag_emit_class_files && !flag_emit_xref)
12169         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12170       /* The same applies to wfl_op2 */
12171       wfl_op2 = TREE_OPERAND (node, 1);
12172       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12173       if (TREE_OPERAND (node, 1) == error_mark_node)
12174         return error_mark_node;
12175       if (!flag_emit_class_files && !flag_emit_xref)
12176         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12177       return patch_array_ref (node);
12178
12179     case RECORD_TYPE:
12180       return node;;
12181
12182     case COMPONENT_REF:
12183       /* The first step in the re-write of qualified name handling.  FIXME.
12184          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12185       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12186       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12187         {
12188           tree name = TREE_OPERAND (node, 1);
12189           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12190           if (field == NULL_TREE)
12191             {
12192               error ("missing static field `%s'", IDENTIFIER_POINTER (name));
12193               return error_mark_node;
12194             }
12195           if (! FIELD_STATIC (field))
12196             {
12197               error ("not a static field `%s'", IDENTIFIER_POINTER (name));
12198               return error_mark_node;
12199             }
12200           return field;
12201         }
12202       else
12203         abort ();
12204       break;
12205
12206     case THIS_EXPR:
12207       /* Can't use THIS in a static environment */
12208       if (!current_this)
12209         {
12210           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12211           parse_error_context (wfl_operator,
12212                                "Keyword `this' used outside allowed context");
12213           TREE_TYPE (node) = error_mark_node;
12214           return error_mark_node;
12215         }
12216       if (ctxp->explicit_constructor_p)
12217         {
12218           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12219           parse_error_context
12220             (wfl_operator, "Can't reference `this' or `super' before the superclass constructor has been called");
12221           TREE_TYPE (node) = error_mark_node;
12222           return error_mark_node;
12223         }
12224       return current_this;
12225
12226     case CLASS_LITERAL:
12227       CAN_COMPLETE_NORMALLY (node) = 1;
12228       node = patch_incomplete_class_ref (node);
12229       if (node == error_mark_node)
12230         return error_mark_node;
12231       break;
12232
12233     default:
12234       CAN_COMPLETE_NORMALLY (node) = 1;
12235       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12236          and it's time to turn it into the appropriate String object */
12237       if ((nn = patch_string (node)))
12238         node = nn;
12239       else
12240         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12241     }
12242   return node;
12243 }
12244
12245 /* Complete function call's argument. Return a nonzero value is an
12246    error was found.  */
12247
12248 static int
12249 complete_function_arguments (tree node)
12250 {
12251   int flag = 0;
12252   tree cn;
12253
12254   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12255   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12256     {
12257       tree wfl = TREE_VALUE (cn), parm, temp;
12258       parm = java_complete_tree (wfl);
12259
12260       if (parm == error_mark_node)
12261         {
12262           flag = 1;
12263           continue;
12264         }
12265       /* If have a string literal that we haven't transformed yet or a
12266          crafted string buffer, as a result of use of the the String
12267          `+' operator. Build `parm.toString()' and expand it. */
12268       if ((temp = patch_string (parm)))
12269         parm = temp;
12270
12271       TREE_VALUE (cn) = parm;
12272     }
12273   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12274   return flag;
12275 }
12276
12277 /* Sometimes (for loops and variable initialized during their
12278    declaration), we want to wrap a statement around a WFL and turn it
12279    debugable.  */
12280
12281 static tree
12282 build_debugable_stmt (int location, tree stmt)
12283 {
12284   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12285     {
12286       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12287       EXPR_WFL_LINECOL (stmt) = location;
12288     }
12289   JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12290   return stmt;
12291 }
12292
12293 static tree
12294 build_expr_block (tree body, tree decls)
12295
12296 {
12297   tree node = make_node (BLOCK);
12298   BLOCK_EXPR_DECLS (node) = decls;
12299   BLOCK_EXPR_BODY (node) = body;
12300   if (body)
12301     TREE_TYPE (node) = TREE_TYPE (body);
12302   TREE_SIDE_EFFECTS (node) = 1;
12303   return node;
12304 }
12305
12306 /* Create a new function block and link it appropriately to current
12307    function block chain */
12308
12309 static tree
12310 enter_block (void)
12311 {
12312   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12313
12314   /* Link block B supercontext to the previous block. The current
12315      function DECL is used as supercontext when enter_a_block is called
12316      for the first time for a given function. The current function body
12317      (DECL_FUNCTION_BODY) is set to be block B.  */
12318
12319   tree fndecl = current_function_decl;
12320
12321   if (!fndecl) {
12322     BLOCK_SUPERCONTEXT (b) = current_static_block;
12323     current_static_block = b;
12324   }
12325
12326   else if (!DECL_FUNCTION_BODY (fndecl))
12327     {
12328       BLOCK_SUPERCONTEXT (b) = fndecl;
12329       DECL_FUNCTION_BODY (fndecl) = b;
12330     }
12331   else
12332     {
12333       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12334       DECL_FUNCTION_BODY (fndecl) = b;
12335     }
12336   return b;
12337 }
12338
12339 /* Exit a block by changing the current function body
12340    (DECL_FUNCTION_BODY) to the current block super context, only if
12341    the block being exited isn't the method's top level one.  */
12342
12343 static tree
12344 exit_block (void)
12345 {
12346   tree b;
12347   if (current_function_decl)
12348     {
12349       b = DECL_FUNCTION_BODY (current_function_decl);
12350       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12351         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12352     }
12353   else
12354     {
12355       b = current_static_block;
12356
12357       if (BLOCK_SUPERCONTEXT (b))
12358         current_static_block = BLOCK_SUPERCONTEXT (b);
12359     }
12360   return b;
12361 }
12362
12363 /* Lookup for NAME in the nested function's blocks, all the way up to
12364    the current toplevel one. It complies with Java's local variable
12365    scoping rules.  */
12366
12367 static tree
12368 lookup_name_in_blocks (tree name)
12369 {
12370   tree b = GET_CURRENT_BLOCK (current_function_decl);
12371
12372   while (b != current_function_decl)
12373     {
12374       tree current;
12375
12376       /* Paranoid sanity check. To be removed */
12377       if (TREE_CODE (b) != BLOCK)
12378         abort ();
12379
12380       for (current = BLOCK_EXPR_DECLS (b); current;
12381            current = TREE_CHAIN (current))
12382         if (DECL_NAME (current) == name)
12383           return current;
12384       b = BLOCK_SUPERCONTEXT (b);
12385     }
12386   return NULL_TREE;
12387 }
12388
12389 static void
12390 maybe_absorb_scoping_blocks (void)
12391 {
12392   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12393     {
12394       tree b = exit_block ();
12395       java_method_add_stmt (current_function_decl, b);
12396       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12397     }
12398 }
12399
12400 \f
12401 /* This section of the source is reserved to build_* functions that
12402    are building incomplete tree nodes and the patch_* functions that
12403    are completing them.  */
12404
12405 /* Wrap a non WFL node around a WFL.  */
12406
12407 static tree
12408 build_wfl_wrap (tree node, int location)
12409 {
12410   tree wfl, node_to_insert = node;
12411
12412   /* We want to process THIS . xxx symbolically, to keep it consistent
12413      with the way we're processing SUPER. A THIS from a primary as a
12414      different form than a SUPER. Turn THIS into something symbolic */
12415   if (TREE_CODE (node) == THIS_EXPR)
12416     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12417   else
12418     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12419
12420   EXPR_WFL_LINECOL (wfl) = location;
12421   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12422   return wfl;
12423 }
12424
12425 /* Build a super() constructor invocation. Returns empty_stmt_node if
12426    we're currently dealing with the class java.lang.Object. */
12427
12428 static tree
12429 build_super_invocation (tree mdecl)
12430 {
12431   if (DECL_CONTEXT (mdecl) == object_type_node)
12432     return empty_stmt_node;
12433   else
12434     {
12435       tree super_wfl = build_wfl_node (super_identifier_node);
12436       tree a = NULL_TREE, t;
12437       /* If we're dealing with an anonymous class, pass the arguments
12438          of the crafted constructor along. */
12439       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12440         {
12441           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12442           for (; t != end_params_node; t = TREE_CHAIN (t))
12443             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12444         }
12445       return build_method_invocation (super_wfl, a);
12446     }
12447 }
12448
12449 /* Build a SUPER/THIS qualified method invocation.  */
12450
12451 static tree
12452 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12453                                        int lloc, int rloc)
12454 {
12455   tree invok;
12456   tree wfl =
12457     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12458   EXPR_WFL_LINECOL (wfl) = lloc;
12459   invok = build_method_invocation (name, args);
12460   return make_qualified_primary (wfl, invok, rloc);
12461 }
12462
12463 /* Build an incomplete CALL_EXPR node. */
12464
12465 static tree
12466 build_method_invocation (tree name, tree args)
12467 {
12468   tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12469   TREE_SIDE_EFFECTS (call) = 1;
12470   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12471   return call;
12472 }
12473
12474 /* Build an incomplete new xxx(...) node. */
12475
12476 static tree
12477 build_new_invocation (tree name, tree args)
12478 {
12479   tree call = build (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12480   TREE_SIDE_EFFECTS (call) = 1;
12481   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12482   return call;
12483 }
12484
12485 /* Build an incomplete assignment expression. */
12486
12487 static tree
12488 build_assignment (int op, int op_location, tree lhs, tree rhs)
12489 {
12490   tree assignment;
12491   /* Build the corresponding binop if we deal with a Compound
12492      Assignment operator. Mark the binop sub-tree as part of a
12493      Compound Assignment expression */
12494   if (op != ASSIGN_TK)
12495     {
12496       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12497       COMPOUND_ASSIGN_P (rhs) = 1;
12498     }
12499   assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12500   TREE_SIDE_EFFECTS (assignment) = 1;
12501   EXPR_WFL_LINECOL (assignment) = op_location;
12502   return assignment;
12503 }
12504
12505 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12506    the buffer.  This is used only for string conversion.  */
12507 static char *
12508 string_convert_int_cst (tree node)
12509 {
12510   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12511   static char buffer[21];
12512
12513   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12514   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12515   char *p = buffer + sizeof (buffer);
12516   int neg = 0;
12517
12518   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12519                                   << (HOST_BITS_PER_WIDE_INT - 1));
12520
12521   *--p = '\0';
12522
12523   /* If negative, note the fact and negate the value.  */
12524   if ((hi & hibit))
12525     {
12526       lo = ~lo;
12527       hi = ~hi;
12528       if (++lo == 0)
12529         ++hi;
12530       neg = 1;
12531     }
12532
12533   /* Divide by 10 until there are no bits left.  */
12534   do
12535     {
12536       unsigned HOST_WIDE_INT acc = 0;
12537       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12538       unsigned int i;
12539
12540       /* Use long division to compute the result and the remainder.  */
12541       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12542         {
12543           /* Shift a bit into accumulator.  */
12544           acc <<= 1;
12545           if ((hi & hibit))
12546             acc |= 1;
12547
12548           /* Shift the value.  */
12549           hi <<= 1;
12550           if ((lo & hibit))
12551             hi |= 1;
12552           lo <<= 1;
12553
12554           /* Shift the correct bit into the result.  */
12555           outhi <<= 1;
12556           if ((outlo & hibit))
12557             outhi |= 1;
12558           outlo <<= 1;
12559           if (acc >= 10)
12560             {
12561               acc -= 10;
12562               outlo |= 1;
12563             }
12564         }
12565
12566       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12567       *--p = '\060' + acc;
12568
12569       hi = outhi;
12570       lo = outlo;
12571     }
12572   while (hi || lo);
12573
12574   if (neg)
12575     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12576
12577   return p;
12578 }
12579
12580 /* Print an INTEGER_CST node in a static buffer, and return the
12581    buffer.  This is used only for error handling.  */
12582 char *
12583 print_int_node (tree node)
12584 {
12585   static char buffer [80];
12586   if (TREE_CONSTANT_OVERFLOW (node))
12587     sprintf (buffer, "<overflow>");
12588
12589   if (TREE_INT_CST_HIGH (node) == 0)
12590     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12591              TREE_INT_CST_LOW (node));
12592   else if (TREE_INT_CST_HIGH (node) == -1
12593            && TREE_INT_CST_LOW (node) != 0)
12594     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12595              -TREE_INT_CST_LOW (node));
12596   else
12597     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12598              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12599
12600   return buffer;
12601 }
12602
12603 \f
12604 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12605    context.  */
12606
12607 /* 15.25 Assignment operators. */
12608
12609 static tree
12610 patch_assignment (tree node, tree wfl_op1)
12611 {
12612   tree rhs = TREE_OPERAND (node, 1);
12613   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12614   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12615   int error_found = 0;
12616   int lvalue_from_array = 0;
12617   int is_return = 0;
12618
12619   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12620
12621   /* Lhs can be a named variable */
12622   if (JDECL_P (lvalue))
12623     {
12624       lhs_type = TREE_TYPE (lvalue);
12625     }
12626   /* Or Lhs can be an array access. */
12627   else if (TREE_CODE (lvalue) == ARRAY_REF)
12628     {
12629       lhs_type = TREE_TYPE (lvalue);
12630       lvalue_from_array = 1;
12631     }
12632   /* Or a field access */
12633   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12634     lhs_type = TREE_TYPE (lvalue);
12635   /* Or a function return slot */
12636   else if (TREE_CODE (lvalue) == RESULT_DECL)
12637     {
12638       /* If the return type is an integral type, then we create the
12639          RESULT_DECL with a promoted type, but we need to do these
12640          checks against the unpromoted type to ensure type safety.  So
12641          here we look at the real type, not the type of the decl we
12642          are modifying.  */
12643       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12644       is_return = 1;
12645     }
12646   /* Otherwise, we might want to try to write into an optimized static
12647      final, this is an of a different nature, reported further on. */
12648   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12649            && resolve_expression_name (wfl_op1, &llvalue))
12650     {
12651       lhs_type = TREE_TYPE (lvalue);
12652     }
12653   else
12654     {
12655       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12656       error_found = 1;
12657     }
12658
12659   rhs_type = TREE_TYPE (rhs);
12660
12661   /* 5.1 Try the assignment conversion for builtin type. */
12662   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12663
12664   /* 5.2 If it failed, try a reference conversion */
12665   if (!new_rhs)
12666     new_rhs = try_reference_assignconv (lhs_type, rhs);
12667
12668   /* 15.25.2 If we have a compound assignment, convert RHS into the
12669      type of the LHS */
12670   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12671     new_rhs = convert (lhs_type, rhs);
12672
12673   /* Explicit cast required. This is an error */
12674   if (!new_rhs)
12675     {
12676       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12677       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12678       tree wfl;
12679       char operation [32];      /* Max size known */
12680
12681       /* If the assignment is part of a declaration, we use the WFL of
12682          the declared variable to point out the error and call it a
12683          declaration problem. If the assignment is a genuine =
12684          operator, we call is a operator `=' problem, otherwise we
12685          call it an assignment problem. In both of these last cases,
12686          we use the WFL of the operator to indicate the error. */
12687
12688       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12689         {
12690           wfl = wfl_op1;
12691           strcpy (operation, "declaration");
12692         }
12693       else
12694         {
12695           wfl = wfl_operator;
12696           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12697             strcpy (operation, "assignment");
12698           else if (is_return)
12699             strcpy (operation, "`return'");
12700           else
12701             strcpy (operation, "`='");
12702         }
12703
12704       if (!valid_cast_to_p (rhs_type, lhs_type))
12705         parse_error_context
12706           (wfl, "Incompatible type for %s. Can't convert `%s' to `%s'",
12707            operation, t1, t2);
12708       else
12709         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert `%s' to `%s'",
12710                              operation, t1, t2);
12711       free (t1); free (t2);
12712       error_found = 1;
12713     }
12714
12715   if (error_found)
12716     return error_mark_node;
12717
12718   /* If we're processing a `return' statement, promote the actual type
12719      to the promoted type.  */
12720   if (is_return)
12721     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12722
12723   /* 10.10: Array Store Exception runtime check */
12724   if (!flag_emit_class_files
12725       && !flag_emit_xref
12726       && lvalue_from_array
12727       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12728     {
12729       tree array, store_check, base, index_expr;
12730
12731       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12732       new_rhs = save_expr (new_rhs);
12733
12734       /* Get the INDIRECT_REF. */
12735       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12736       /* Get the array pointer expr. */
12737       array = TREE_OPERAND (array, 0);
12738       store_check = build_java_arraystore_check (array, new_rhs);
12739
12740       index_expr = TREE_OPERAND (lvalue, 1);
12741
12742       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12743         {
12744           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12745              happen before the store check, so prepare to insert the store
12746              check within the second operand of the existing COMPOUND_EXPR. */
12747           base = index_expr;
12748         }
12749       else
12750         base = lvalue;
12751
12752       index_expr = TREE_OPERAND (base, 1);
12753       TREE_OPERAND (base, 1) = build (COMPOUND_EXPR, TREE_TYPE (index_expr),
12754                                       store_check, index_expr);
12755     }
12756
12757   /* Final locals can be used as case values in switch
12758      statement. Prepare them for this eventuality. */
12759   if (TREE_CODE (lvalue) == VAR_DECL
12760       && DECL_FINAL (lvalue)
12761       && TREE_CONSTANT (new_rhs)
12762       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12763       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12764       )
12765     {
12766       TREE_CONSTANT (lvalue) = 1;
12767       DECL_INITIAL (lvalue) = new_rhs;
12768     }
12769
12770   /* Copy the rhs if it's a reference.  */
12771   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12772     {
12773       switch (TREE_CODE (new_rhs))
12774         {
12775         case ARRAY_REF:
12776         case INDIRECT_REF:
12777         case COMPONENT_REF:
12778           /* Transform a = foo.bar
12779              into a = { int tmp; tmp = foo.bar; tmp; ).
12780              We need to ensure that if a read from memory fails
12781              because of a NullPointerException, a destination variable
12782              will remain unchanged.  An explicit temporary does what
12783              we need.
12784
12785              If flag_check_references is set, this is unnecessary
12786              because we'll check each reference before doing any
12787              reads.  If optimize is not set the result will never be
12788              written to a stack slot that contains the LHS.  */
12789           {
12790             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12791                                    TREE_TYPE (new_rhs));
12792             tree block = make_node (BLOCK);
12793             tree assignment
12794               = build (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12795             DECL_CONTEXT (tmp) = current_function_decl;
12796             TREE_TYPE (block) = TREE_TYPE (new_rhs);
12797             BLOCK_VARS (block) = tmp;
12798             BLOCK_EXPR_BODY (block)
12799               = build (COMPOUND_EXPR, TREE_TYPE (new_rhs), assignment, tmp);
12800             TREE_SIDE_EFFECTS (block) = 1;
12801             new_rhs = block;
12802           }
12803           break;
12804         default:
12805           break;
12806         }
12807     }
12808
12809   TREE_OPERAND (node, 0) = lvalue;
12810   TREE_OPERAND (node, 1) = new_rhs;
12811   TREE_TYPE (node) = lhs_type;
12812   return node;
12813 }
12814
12815 /* Check that type SOURCE can be cast into type DEST. If the cast
12816    can't occur at all, return NULL; otherwise, return a possibly
12817    modified rhs.  */
12818
12819 static tree
12820 try_reference_assignconv (tree lhs_type, tree rhs)
12821 {
12822   tree new_rhs = NULL_TREE;
12823   tree rhs_type = TREE_TYPE (rhs);
12824
12825   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12826     {
12827       /* `null' may be assigned to any reference type */
12828       if (rhs == null_pointer_node)
12829         new_rhs = null_pointer_node;
12830       /* Try the reference assignment conversion */
12831       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12832         new_rhs = rhs;
12833       /* This is a magic assignment that we process differently */
12834       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12835         new_rhs = rhs;
12836     }
12837   return new_rhs;
12838 }
12839
12840 /* Check that RHS can be converted into LHS_TYPE by the assignment
12841    conversion (5.2), for the cases of RHS being a builtin type. Return
12842    NULL_TREE if the conversion fails or if because RHS isn't of a
12843    builtin type. Return a converted RHS if the conversion is possible.  */
12844
12845 static tree
12846 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12847 {
12848   tree new_rhs = NULL_TREE;
12849   tree rhs_type = TREE_TYPE (rhs);
12850
12851   /* Handle boolean specially.  */
12852   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12853       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12854     {
12855       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12856           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12857         new_rhs = rhs;
12858     }
12859
12860   /* 5.1.1 Try Identity Conversion,
12861      5.1.2 Try Widening Primitive Conversion */
12862   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12863     new_rhs = convert (lhs_type, rhs);
12864
12865   /* Try a narrowing primitive conversion (5.1.3):
12866        - expression is a constant expression of type byte, short, char,
12867          or int, AND
12868        - variable is byte, short or char AND
12869        - The value of the expression is representable in the type of the
12870          variable */
12871   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12872             || rhs_type == char_type_node || rhs_type == int_type_node)
12873             && TREE_CONSTANT (rhs)
12874            && (lhs_type == byte_type_node || lhs_type == char_type_node
12875                || lhs_type == short_type_node))
12876     {
12877       if (int_fits_type_p (rhs, lhs_type))
12878         new_rhs = convert (lhs_type, rhs);
12879       else if (wfl_op1)         /* Might be called with a NULL */
12880         parse_warning_context
12881           (wfl_op1, "Constant expression `%s' too wide for narrowing primitive conversion to `%s'",
12882            print_int_node (rhs), lang_printable_name (lhs_type, 0));
12883       /* Reported a warning that will turn into an error further
12884          down, so we don't return */
12885     }
12886
12887   return new_rhs;
12888 }
12889
12890 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12891    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12892    0 is the conversion test fails.  This implements parts the method
12893    invocation conversion (5.3).  */
12894
12895 static int
12896 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
12897 {
12898   /* 5.1.1: This is the identity conversion part. */
12899   if (lhs_type == rhs_type)
12900     return 1;
12901
12902   /* Reject non primitive types and boolean conversions.  */
12903   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
12904     return 0;
12905
12906   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
12907      than a char can't be converted into a char. Short can't too, but
12908      the < test below takes care of that */
12909   if (lhs_type == char_type_node && rhs_type == byte_type_node)
12910     return 0;
12911
12912   /* Accept all promoted type here. Note, we can't use <= in the test
12913      below, because we still need to bounce out assignments of short
12914      to char and the likes */
12915   if (lhs_type == int_type_node
12916       && (rhs_type == promoted_byte_type_node
12917           || rhs_type == promoted_short_type_node
12918           || rhs_type == promoted_char_type_node
12919           || rhs_type == promoted_boolean_type_node))
12920     return 1;
12921
12922   /* From here, an integral is widened if its precision is smaller
12923      than the precision of the LHS or if the LHS is a floating point
12924      type, or the RHS is a float and the RHS a double. */
12925   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
12926        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
12927       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
12928       || (rhs_type == float_type_node && lhs_type == double_type_node))
12929     return 1;
12930
12931   return 0;
12932 }
12933
12934 /* Check that something of SOURCE type can be assigned or cast to
12935    something of DEST type at runtime. Return 1 if the operation is
12936    valid, 0 otherwise. If CAST is set to 1, we're treating the case
12937    were SOURCE is cast into DEST, which borrows a lot of the
12938    assignment check. */
12939
12940 static int
12941 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
12942 {
12943   /* SOURCE or DEST might be null if not from a declared entity. */
12944   if (!source || !dest)
12945     return 0;
12946   if (JNULLP_TYPE_P (source))
12947     return 1;
12948   if (TREE_CODE (source) == POINTER_TYPE)
12949     source = TREE_TYPE (source);
12950   if (TREE_CODE (dest) == POINTER_TYPE)
12951     dest = TREE_TYPE (dest);
12952
12953   /* If source and dest are being compiled from bytecode, they may need to
12954      be loaded. */
12955   if (CLASS_P (source) && !CLASS_LOADED_P (source))
12956     {
12957       load_class (source, 1);
12958       safe_layout_class (source);
12959     }
12960   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
12961     {
12962       load_class (dest, 1);
12963       safe_layout_class (dest);
12964     }
12965
12966   /* Case where SOURCE is a class type */
12967   if (TYPE_CLASS_P (source))
12968     {
12969       if (TYPE_CLASS_P (dest))
12970         return  (source == dest
12971                  || inherits_from_p (source, dest)
12972                  || (cast && inherits_from_p (dest, source)));
12973       if (TYPE_INTERFACE_P (dest))
12974         {
12975           /* If doing a cast and SOURCE is final, the operation is
12976              always correct a compile time (because even if SOURCE
12977              does not implement DEST, a subclass of SOURCE might). */
12978           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
12979             return 1;
12980           /* Otherwise, SOURCE must implement DEST */
12981           return interface_of_p (dest, source);
12982         }
12983       /* DEST is an array, cast permitted if SOURCE is of Object type */
12984       return (cast && source == object_type_node ? 1 : 0);
12985     }
12986   if (TYPE_INTERFACE_P (source))
12987     {
12988       if (TYPE_CLASS_P (dest))
12989         {
12990           /* If not casting, DEST must be the Object type */
12991           if (!cast)
12992             return dest == object_type_node;
12993           /* We're doing a cast. The cast is always valid is class
12994              DEST is not final, otherwise, DEST must implement SOURCE */
12995           else if (!CLASS_FINAL (TYPE_NAME (dest)))
12996             return 1;
12997           else
12998             return interface_of_p (source, dest);
12999         }
13000       if (TYPE_INTERFACE_P (dest))
13001         {
13002           /* If doing a cast, then if SOURCE and DEST contain method
13003              with the same signature but different return type, then
13004              this is a (compile time) error */
13005           if (cast)
13006             {
13007               tree method_source, method_dest;
13008               tree source_type;
13009               tree source_sig;
13010               tree source_name;
13011               for (method_source = TYPE_METHODS (source); method_source;
13012                    method_source = TREE_CHAIN (method_source))
13013                 {
13014                   source_sig =
13015                     build_java_argument_signature (TREE_TYPE (method_source));
13016                   source_type = TREE_TYPE (TREE_TYPE (method_source));
13017                   source_name = DECL_NAME (method_source);
13018                   for (method_dest = TYPE_METHODS (dest);
13019                        method_dest; method_dest = TREE_CHAIN (method_dest))
13020                     if (source_sig ==
13021                         build_java_argument_signature (TREE_TYPE (method_dest))
13022                         && source_name == DECL_NAME (method_dest)
13023                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
13024                       return 0;
13025                 }
13026               return 1;
13027             }
13028           else
13029             return source == dest || interface_of_p (dest, source);
13030         }
13031       else
13032         {
13033           /* Array */
13034           return (cast
13035                   && (DECL_NAME (TYPE_NAME (source))
13036                       == java_lang_cloneable_identifier_node
13037                       || (DECL_NAME (TYPE_NAME (source))
13038                           == java_io_serializable_identifier_node)));
13039         }
13040     }
13041   if (TYPE_ARRAY_P (source))
13042     {
13043       if (TYPE_CLASS_P (dest))
13044         return dest == object_type_node;
13045       /* Can't cast an array to an interface unless the interface is
13046          java.lang.Cloneable or java.io.Serializable.  */
13047       if (TYPE_INTERFACE_P (dest))
13048         return (DECL_NAME (TYPE_NAME (dest))
13049                 == java_lang_cloneable_identifier_node
13050                 || (DECL_NAME (TYPE_NAME (dest))
13051                     == java_io_serializable_identifier_node));
13052       else                      /* Arrays */
13053         {
13054           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13055           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13056
13057           /* In case of severe errors, they turn out null */
13058           if (!dest_element_type || !source_element_type)
13059             return 0;
13060           if (source_element_type == dest_element_type)
13061             return 1;
13062           return valid_ref_assignconv_cast_p (source_element_type,
13063                                               dest_element_type, cast);
13064         }
13065       return 0;
13066     }
13067   return 0;
13068 }
13069
13070 static int
13071 valid_cast_to_p (tree source, tree dest)
13072 {
13073   if (TREE_CODE (source) == POINTER_TYPE)
13074     source = TREE_TYPE (source);
13075   if (TREE_CODE (dest) == POINTER_TYPE)
13076     dest = TREE_TYPE (dest);
13077
13078   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13079     return valid_ref_assignconv_cast_p (source, dest, 1);
13080
13081   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13082     return 1;
13083
13084   else if (TREE_CODE (source) == BOOLEAN_TYPE
13085            && TREE_CODE (dest) == BOOLEAN_TYPE)
13086     return 1;
13087
13088   return 0;
13089 }
13090
13091 static tree
13092 do_unary_numeric_promotion (tree arg)
13093 {
13094   tree type = TREE_TYPE (arg);
13095   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13096       || TREE_CODE (type) == CHAR_TYPE)
13097     arg = convert (int_type_node, arg);
13098   return arg;
13099 }
13100
13101 /* Return a nonzero value if SOURCE can be converted into DEST using
13102    the method invocation conversion rule (5.3).  */
13103 static int
13104 valid_method_invocation_conversion_p (tree dest, tree source)
13105 {
13106   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13107            && valid_builtin_assignconv_identity_widening_p (dest, source))
13108           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13109               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13110               && valid_ref_assignconv_cast_p (source, dest, 0)));
13111 }
13112
13113 /* Build an incomplete binop expression. */
13114
13115 static tree
13116 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13117 {
13118   tree binop = build (op, NULL_TREE, op1, op2);
13119   TREE_SIDE_EFFECTS (binop) = 1;
13120   /* Store the location of the operator, for better error report. The
13121      string of the operator will be rebuild based on the OP value. */
13122   EXPR_WFL_LINECOL (binop) = op_location;
13123   return binop;
13124 }
13125
13126 /* Build the string of the operator retained by NODE. If NODE is part
13127    of a compound expression, add an '=' at the end of the string. This
13128    function is called when an error needs to be reported on an
13129    operator. The string is returned as a pointer to a static character
13130    buffer. */
13131
13132 static char *
13133 operator_string (tree node)
13134 {
13135 #define BUILD_OPERATOR_STRING(S)                                        \
13136   {                                                                     \
13137     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13138     return buffer;                                                      \
13139   }
13140
13141   static char buffer [10];
13142   switch (TREE_CODE (node))
13143     {
13144     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13145     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13146     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13147     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13148     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13149     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13150     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13151     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13152     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13153     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13154     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13155     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13156     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13157     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13158     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13159     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13160     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13161     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13162     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13163     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13164     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13165     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13166     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13167     case PREINCREMENT_EXPR:     /* Fall through */
13168     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13169     case PREDECREMENT_EXPR:     /* Fall through */
13170     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13171     default:
13172       internal_error ("unregistered operator %s",
13173                       tree_code_name [TREE_CODE (node)]);
13174     }
13175   return NULL;
13176 #undef BUILD_OPERATOR_STRING
13177 }
13178
13179 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13180
13181 static int
13182 java_decl_equiv (tree var_acc1, tree var_acc2)
13183 {
13184   if (JDECL_P (var_acc1))
13185     return (var_acc1 == var_acc2);
13186
13187   return (TREE_CODE (var_acc1) == COMPONENT_REF
13188           && TREE_CODE (var_acc2) == COMPONENT_REF
13189           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13190              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13191           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13192 }
13193
13194 /* Return a nonzero value if CODE is one of the operators that can be
13195    used in conjunction with the `=' operator in a compound assignment.  */
13196
13197 static int
13198 binop_compound_p (enum tree_code code)
13199 {
13200   int i;
13201   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13202     if (binop_lookup [i] == code)
13203       break;
13204
13205   return i < BINOP_COMPOUND_CANDIDATES;
13206 }
13207
13208 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13209
13210 static tree
13211 java_refold (tree t)
13212 {
13213   tree c, b, ns, decl;
13214
13215   if (TREE_CODE (t) != MODIFY_EXPR)
13216     return t;
13217
13218   c = TREE_OPERAND (t, 1);
13219   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13220          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13221          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13222     return t;
13223
13224   /* Now the left branch of the binary operator. */
13225   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13226   if (! (b && TREE_CODE (b) == NOP_EXPR
13227          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13228     return t;
13229
13230   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13231   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13232          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13233     return t;
13234
13235   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13236   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13237       /* It's got to be the an equivalent decl */
13238       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13239     {
13240       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13241       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13242       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13243       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13244       /* Change the right part of the BINOP_EXPR */
13245       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13246     }
13247
13248   return t;
13249 }
13250
13251 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13252    errors but we modify NODE so that it contains the type computed
13253    according to the expression, when it's fixed. Otherwise, we write
13254    error_mark_node as the type. It allows us to further the analysis
13255    of remaining nodes and detects more errors in certain cases.  */
13256
13257 static tree
13258 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13259 {
13260   tree op1 = TREE_OPERAND (node, 0);
13261   tree op2 = TREE_OPERAND (node, 1);
13262   tree op1_type = TREE_TYPE (op1);
13263   tree op2_type = TREE_TYPE (op2);
13264   tree prom_type = NULL_TREE, cn;
13265   enum tree_code code = TREE_CODE (node);
13266
13267   /* If 1, tell the routine that we have to return error_mark_node
13268      after checking for the initialization of the RHS */
13269   int error_found = 0;
13270
13271   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13272
13273   /* If either op<n>_type are NULL, this might be early signs of an
13274      error situation, unless it's too early to tell (in case we're
13275      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13276      correctly so the error can be later on reported accurately. */
13277   if (! (code == PLUS_EXPR || code == NE_EXPR
13278          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13279     {
13280       tree n;
13281       if (! op1_type)
13282         {
13283           n = java_complete_tree (op1);
13284           op1_type = TREE_TYPE (n);
13285         }
13286       if (! op2_type)
13287         {
13288           n = java_complete_tree (op2);
13289           op2_type = TREE_TYPE (n);
13290         }
13291     }
13292
13293   switch (code)
13294     {
13295     /* 15.16 Multiplicative operators */
13296     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13297     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13298     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13299     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13300       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13301         {
13302           if (!JNUMERIC_TYPE_P (op1_type))
13303             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13304           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13305             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13306           TREE_TYPE (node) = error_mark_node;
13307           error_found = 1;
13308           break;
13309         }
13310       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13311
13312       /* Detect integral division by zero */
13313       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13314           && TREE_CODE (prom_type) == INTEGER_TYPE
13315           && (op2 == integer_zero_node || op2 == long_zero_node ||
13316               (TREE_CODE (op2) == INTEGER_CST &&
13317                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13318         {
13319           parse_warning_context (wfl_operator, "Evaluating this expression will result in an arithmetic exception being thrown");
13320           TREE_CONSTANT (node) = 0;
13321         }
13322
13323       /* Change the division operator if necessary */
13324       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13325         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13326
13327       /* Before divisions as is disappear, try to simplify and bail if
13328          applicable, otherwise we won't perform even simple
13329          simplifications like (1-1)/3. We can't do that with floating
13330          point number, folds can't handle them at this stage. */
13331       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13332           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13333         {
13334           TREE_TYPE (node) = prom_type;
13335           node = fold (node);
13336           if (TREE_CODE (node) != code)
13337             return node;
13338         }
13339
13340       if (TREE_CODE (prom_type) == INTEGER_TYPE
13341           && flag_use_divide_subroutine
13342           && ! flag_emit_class_files
13343           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13344         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13345
13346       /* This one is more complicated. FLOATs are processed by a
13347          function call to soft_fmod. Duplicate the value of the
13348          COMPOUND_ASSIGN_P flag. */
13349       if (code == TRUNC_MOD_EXPR)
13350         {
13351           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13352           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13353           TREE_SIDE_EFFECTS (mod)
13354             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13355           return mod;
13356         }
13357       break;
13358
13359     /* 15.17 Additive Operators */
13360     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13361
13362       /* Operation is valid if either one argument is a string
13363          constant, a String object or a StringBuffer crafted for the
13364          purpose of the a previous usage of the String concatenation
13365          operator */
13366
13367       if (TREE_CODE (op1) == STRING_CST
13368           || TREE_CODE (op2) == STRING_CST
13369           || JSTRING_TYPE_P (op1_type)
13370           || JSTRING_TYPE_P (op2_type)
13371           || IS_CRAFTED_STRING_BUFFER_P (op1)
13372           || IS_CRAFTED_STRING_BUFFER_P (op2))
13373         return build_string_concatenation (op1, op2);
13374
13375     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13376                                    Numeric Types */
13377       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13378         {
13379           if (!JNUMERIC_TYPE_P (op1_type))
13380             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13381           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13382             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13383           TREE_TYPE (node) = error_mark_node;
13384           error_found = 1;
13385           break;
13386         }
13387       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13388       break;
13389
13390     /* 15.18 Shift Operators */
13391     case LSHIFT_EXPR:
13392     case RSHIFT_EXPR:
13393     case URSHIFT_EXPR:
13394       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13395         {
13396           if (!JINTEGRAL_TYPE_P (op1_type))
13397             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13398           else
13399             {
13400               if (JNUMERIC_TYPE_P (op2_type))
13401                 parse_error_context (wfl_operator,
13402                                      "Incompatible type for `%s'. Explicit cast needed to convert shift distance from `%s' to integral",
13403                                      operator_string (node),
13404                                      lang_printable_name (op2_type, 0));
13405               else
13406                 parse_error_context (wfl_operator,
13407                                      "Incompatible type for `%s'. Can't convert shift distance from `%s' to integral",
13408                                      operator_string (node),
13409                                      lang_printable_name (op2_type, 0));
13410             }
13411           TREE_TYPE (node) = error_mark_node;
13412           error_found = 1;
13413           break;
13414         }
13415
13416       /* Unary numeric promotion (5.6.1) is performed on each operand
13417          separately */
13418       op1 = do_unary_numeric_promotion (op1);
13419       op2 = do_unary_numeric_promotion (op2);
13420
13421       /* If the right hand side is of type `long', first cast it to
13422          `int'.  */
13423       if (TREE_TYPE (op2) == long_type_node)
13424         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13425
13426       /* The type of the shift expression is the type of the promoted
13427          type of the left-hand operand */
13428       prom_type = TREE_TYPE (op1);
13429
13430       /* Shift int only up to 0x1f and long up to 0x3f */
13431       if (prom_type == int_type_node)
13432         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13433                            build_int_2 (0x1f, 0)));
13434       else
13435         op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
13436                            build_int_2 (0x3f, 0)));
13437
13438       /* The >>> operator is a >> operating on unsigned quantities */
13439       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13440         {
13441           tree to_return;
13442           tree utype = java_unsigned_type (prom_type);
13443           op1 = convert (utype, op1);
13444           TREE_SET_CODE (node, RSHIFT_EXPR);
13445           TREE_OPERAND (node, 0) = op1;
13446           TREE_OPERAND (node, 1) = op2;
13447           TREE_TYPE (node) = utype;
13448           to_return = convert (prom_type, node);
13449           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13450           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13451           TREE_SIDE_EFFECTS (to_return)
13452             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13453           return to_return;
13454         }
13455       break;
13456
13457       /* 15.19.1 Type Comparison Operator instanceof */
13458     case INSTANCEOF_EXPR:
13459
13460       TREE_TYPE (node) = boolean_type_node;
13461
13462       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13463       if ((cn = patch_string (op1)))
13464         {
13465           op1 = cn;
13466           op1_type = TREE_TYPE (op1);
13467         }
13468       if (op1_type == NULL_TREE)
13469         abort ();
13470
13471       if (!(op2_type = resolve_type_during_patch (op2)))
13472         return error_mark_node;
13473
13474       /* The first operand must be a reference type or the null type */
13475       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13476         error_found = 1;        /* Error reported further below */
13477
13478       /* The second operand must be a reference type */
13479       if (!JREFERENCE_TYPE_P (op2_type))
13480         {
13481           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13482           parse_error_context
13483             (wfl_operator, "Invalid argument `%s' for `instanceof'",
13484              lang_printable_name (op2_type, 0));
13485           error_found = 1;
13486         }
13487
13488       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13489         {
13490           /* If the first operand is null, the result is always false */
13491           if (op1 == null_pointer_node)
13492             return boolean_false_node;
13493           else if (flag_emit_class_files)
13494             {
13495               TREE_OPERAND (node, 1) = op2_type;
13496               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13497               return node;
13498             }
13499           /* Otherwise we have to invoke instance of to figure it out */
13500           else
13501             return build_instanceof (op1, op2_type);
13502         }
13503       /* There is no way the expression operand can be an instance of
13504          the type operand. This is a compile time error. */
13505       else
13506         {
13507           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13508           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13509           parse_error_context
13510             (wfl_operator, "Impossible for `%s' to be instance of `%s'",
13511              t1, lang_printable_name (op2_type, 0));
13512           free (t1);
13513           error_found = 1;
13514         }
13515
13516       break;
13517
13518       /* 15.21 Bitwise and Logical Operators */
13519     case BIT_AND_EXPR:
13520     case BIT_XOR_EXPR:
13521     case BIT_IOR_EXPR:
13522       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13523         /* Binary numeric promotion is performed on both operand and the
13524            expression retain that type */
13525         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13526
13527       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13528                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13529         /* The type of the bitwise operator expression is BOOLEAN */
13530         prom_type = boolean_type_node;
13531       else
13532         {
13533           if (!JINTEGRAL_TYPE_P (op1_type))
13534             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13535           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13536             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13537           TREE_TYPE (node) = error_mark_node;
13538           error_found = 1;
13539           /* Insert a break here if adding thing before the switch's
13540              break for this case */
13541         }
13542       break;
13543
13544       /* 15.22 Conditional-And Operator */
13545     case TRUTH_ANDIF_EXPR:
13546       /* 15.23 Conditional-Or Operator */
13547     case TRUTH_ORIF_EXPR:
13548       /* Operands must be of BOOLEAN type */
13549       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13550           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13551         {
13552           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13553             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13554           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13555             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13556           TREE_TYPE (node) = boolean_type_node;
13557           error_found = 1;
13558           break;
13559         }
13560       else if (integer_zerop (op1))
13561         {
13562           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13563         }
13564       else if (integer_onep (op1))
13565         {
13566           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13567         }
13568       /* The type of the conditional operators is BOOLEAN */
13569       prom_type = boolean_type_node;
13570       break;
13571
13572       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13573     case LT_EXPR:
13574     case GT_EXPR:
13575     case LE_EXPR:
13576     case GE_EXPR:
13577       /* The type of each of the operands must be a primitive numeric
13578          type */
13579       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13580         {
13581           if (!JNUMERIC_TYPE_P (op1_type))
13582             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13583           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13584             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13585           TREE_TYPE (node) = boolean_type_node;
13586           error_found = 1;
13587           break;
13588         }
13589       /* Binary numeric promotion is performed on the operands */
13590       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13591       /* The type of the relation expression is always BOOLEAN */
13592       prom_type = boolean_type_node;
13593       break;
13594
13595       /* 15.20 Equality Operator */
13596     case EQ_EXPR:
13597     case NE_EXPR:
13598       /* It's time for us to patch the strings. */
13599       if ((cn = patch_string (op1)))
13600        {
13601          op1 = cn;
13602          op1_type = TREE_TYPE (op1);
13603        }
13604       if ((cn = patch_string (op2)))
13605        {
13606          op2 = cn;
13607          op2_type = TREE_TYPE (op2);
13608        }
13609
13610       /* 15.20.1 Numerical Equality Operators == and != */
13611       /* Binary numeric promotion is performed on the operands */
13612       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13613         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13614
13615       /* 15.20.2 Boolean Equality Operators == and != */
13616       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13617           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13618         ;                       /* Nothing to do here */
13619
13620       /* 15.20.3 Reference Equality Operators == and != */
13621       /* Types have to be either references or the null type. If
13622          they're references, it must be possible to convert either
13623          type to the other by casting conversion. */
13624       else if (op1 == null_pointer_node || op2 == null_pointer_node
13625                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13626                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13627                        || valid_ref_assignconv_cast_p (op2_type,
13628                                                        op1_type, 1))))
13629         ;                       /* Nothing to do here */
13630
13631       /* Else we have an error figure what can't be converted into
13632          what and report the error */
13633       else
13634         {
13635           char *t1;
13636           t1 = xstrdup (lang_printable_name (op1_type, 0));
13637           parse_error_context
13638             (wfl_operator,
13639              "Incompatible type for `%s'. Can't convert `%s' to `%s'",
13640              operator_string (node), t1,
13641              lang_printable_name (op2_type, 0));
13642           free (t1);
13643           TREE_TYPE (node) = boolean_type_node;
13644           error_found = 1;
13645           break;
13646         }
13647       prom_type = boolean_type_node;
13648       break;
13649     default:
13650       abort ();
13651     }
13652
13653   if (error_found)
13654     return error_mark_node;
13655
13656   TREE_OPERAND (node, 0) = op1;
13657   TREE_OPERAND (node, 1) = op2;
13658   TREE_TYPE (node) = prom_type;
13659   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13660
13661   if (flag_emit_xref)
13662     return node;
13663
13664   /* fold does not respect side-effect order as required for Java but not C.
13665    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13666    * bytecode.
13667    */
13668   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13669       : ! TREE_SIDE_EFFECTS (node))
13670     node = fold (node);
13671   return node;
13672 }
13673
13674 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13675    zero value, the value of CSTE comes after the valude of STRING */
13676
13677 static tree
13678 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13679 {
13680   const char *old = TREE_STRING_POINTER (cste);
13681   int old_len = TREE_STRING_LENGTH (cste);
13682   int len = old_len + string_len;
13683   char *new = alloca (len+1);
13684
13685   if (after)
13686     {
13687       memcpy (new, string, string_len);
13688       memcpy (&new [string_len], old, old_len);
13689     }
13690   else
13691     {
13692       memcpy (new, old, old_len);
13693       memcpy (&new [old_len], string, string_len);
13694     }
13695   new [len] = '\0';
13696   return build_string (len, new);
13697 }
13698
13699 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13700    new STRING_CST on success, NULL_TREE on failure.  */
13701
13702 static tree
13703 merge_string_cste (tree op1, tree op2, int after)
13704 {
13705   /* Handle two string constants right away.  */
13706   if (TREE_CODE (op2) == STRING_CST)
13707     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13708                                  TREE_STRING_LENGTH (op2), after);
13709
13710   /* Reasonable integer constant can be treated right away.  */
13711   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13712     {
13713       static const char *const boolean_true = "true";
13714       static const char *const boolean_false = "false";
13715       static const char *const null_pointer = "null";
13716       char ch[4];
13717       const char *string;
13718
13719       if (op2 == boolean_true_node)
13720         string = boolean_true;
13721       else if (op2 == boolean_false_node)
13722         string = boolean_false;
13723       else if (op2 == null_pointer_node
13724                || (integer_zerop (op2)
13725                    && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
13726         /* FIXME: null is not a compile-time constant, so it is only safe to
13727            merge if the overall expression is non-constant. However, this
13728            code always merges without checking the overall expression.  */
13729         string = null_pointer;
13730       else if (TREE_TYPE (op2) == char_type_node)
13731         {
13732           /* Convert the character into UTF-8.  */
13733           unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13734           unsigned char *p = (unsigned char *) ch;
13735           if (0x01 <= c && c <= 0x7f)
13736             *p++ = (unsigned char) c;
13737           else if (c < 0x7ff)
13738             {
13739               *p++ = (unsigned char) (c >> 6 | 0xc0);
13740               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13741             }
13742           else
13743             {
13744               *p++ = (unsigned char) (c >> 12 | 0xe0);
13745               *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13746               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13747             }
13748           *p = '\0';
13749
13750           string = ch;
13751         }
13752       else
13753         string = string_convert_int_cst (op2);
13754
13755       return do_merge_string_cste (op1, string, strlen (string), after);
13756     }
13757   return NULL_TREE;
13758 }
13759
13760 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13761    has to be a STRING_CST and the other part must be a STRING_CST or a
13762    INTEGRAL constant. Return a new STRING_CST if the operation
13763    succeed, NULL_TREE otherwise.
13764
13765    If the case we want to optimize for space, we might want to return
13766    NULL_TREE for each invocation of this routine. FIXME */
13767
13768 static tree
13769 string_constant_concatenation (tree op1, tree op2)
13770 {
13771   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13772     {
13773       tree string, rest;
13774       int invert;
13775
13776       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13777       rest   = (string == op1 ? op2 : op1);
13778       invert = (string == op1 ? 0 : 1 );
13779
13780       /* Walk REST, only if it looks reasonable */
13781       if (TREE_CODE (rest) != STRING_CST
13782           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13783           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13784           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13785         {
13786           rest = java_complete_tree (rest);
13787           if (rest == error_mark_node)
13788             return error_mark_node;
13789           rest = fold (rest);
13790         }
13791       return merge_string_cste (string, rest, invert);
13792     }
13793   return NULL_TREE;
13794 }
13795
13796 /* Implement the `+' operator. Does static optimization if possible,
13797    otherwise create (if necessary) and append elements to a
13798    StringBuffer. The StringBuffer will be carried around until it is
13799    used for a function call or an assignment. Then toString() will be
13800    called on it to turn it into a String object. */
13801
13802 static tree
13803 build_string_concatenation (tree op1, tree op2)
13804 {
13805   tree result;
13806   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13807
13808   if (flag_emit_xref)
13809     return build (PLUS_EXPR, string_type_node, op1, op2);
13810
13811   /* Try to do some static optimization */
13812   if ((result = string_constant_concatenation (op1, op2)))
13813     return result;
13814
13815   /* Discard empty strings on either side of the expression */
13816   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13817     {
13818       op1 = op2;
13819       op2 = NULL_TREE;
13820     }
13821   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13822     op2 = NULL_TREE;
13823
13824   /* If operands are string constant, turn then into object references */
13825   if (TREE_CODE (op1) == STRING_CST)
13826     op1 = patch_string_cst (op1);
13827   if (op2 && TREE_CODE (op2) == STRING_CST)
13828     op2 = patch_string_cst (op2);
13829
13830   /* If either one of the constant is null and the other non null
13831      operand is a String constant, return it. */
13832   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13833     return op1;
13834
13835   /* If OP1 isn't already a StringBuffer, create and
13836      initialize a new one */
13837   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13838     {
13839       /* Two solutions here:
13840          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13841          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13842       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13843         op1 = BUILD_STRING_BUFFER (op1);
13844       else
13845         {
13846           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13847           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13848         }
13849     }
13850
13851   if (op2)
13852     {
13853       /* OP1 is no longer the last node holding a crafted StringBuffer */
13854       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13855       /* Create a node for `{new...,xxx}.append (op2)' */
13856       if (op2)
13857         op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13858     }
13859
13860   /* Mark the last node holding a crafted StringBuffer */
13861   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13862
13863   TREE_SIDE_EFFECTS (op1) = side_effects;
13864   return op1;
13865 }
13866
13867 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13868    StringBuffer. If no string were found to be patched, return
13869    NULL. */
13870
13871 static tree
13872 patch_string (tree node)
13873 {
13874   if (node == error_mark_node)
13875     return error_mark_node;
13876   if (TREE_CODE (node) == STRING_CST)
13877     return patch_string_cst (node);
13878   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13879     {
13880       int saved = ctxp->explicit_constructor_p;
13881       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13882       tree ret;
13883       /* Temporary disable forbid the use of `this'. */
13884       ctxp->explicit_constructor_p = 0;
13885       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13886       /* String concatenation arguments must be evaluated in order too. */
13887       ret = force_evaluation_order (ret);
13888       /* Restore it at its previous value */
13889       ctxp->explicit_constructor_p = saved;
13890       return ret;
13891     }
13892   return NULL_TREE;
13893 }
13894
13895 /* Build the internal representation of a string constant.  */
13896
13897 static tree
13898 patch_string_cst (tree node)
13899 {
13900   int location;
13901   if (! flag_emit_class_files)
13902     {
13903       node = get_identifier (TREE_STRING_POINTER (node));
13904       location = alloc_name_constant (CONSTANT_String, node);
13905       node = build_ref_from_constant_pool (location);
13906     }
13907   TREE_TYPE (node) = string_ptr_type_node;
13908   TREE_CONSTANT (node) = 1;
13909   return node;
13910 }
13911
13912 /* Build an incomplete unary operator expression. */
13913
13914 static tree
13915 build_unaryop (int op_token, int op_location, tree op1)
13916 {
13917   enum tree_code op;
13918   tree unaryop;
13919   switch (op_token)
13920     {
13921     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
13922     case MINUS_TK: op = NEGATE_EXPR; break;
13923     case NEG_TK: op = TRUTH_NOT_EXPR; break;
13924     case NOT_TK: op = BIT_NOT_EXPR; break;
13925     default: abort ();
13926     }
13927
13928   unaryop = build1 (op, NULL_TREE, op1);
13929   TREE_SIDE_EFFECTS (unaryop) = 1;
13930   /* Store the location of the operator, for better error report. The
13931      string of the operator will be rebuild based on the OP value. */
13932   EXPR_WFL_LINECOL (unaryop) = op_location;
13933   return unaryop;
13934 }
13935
13936 /* Special case for the ++/-- operators, since they require an extra
13937    argument to build, which is set to NULL and patched
13938    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
13939
13940 static tree
13941 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
13942 {
13943   static const enum tree_code lookup [2][2] =
13944     {
13945       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
13946       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
13947     };
13948   tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
13949                      NULL_TREE, op1, NULL_TREE);
13950   TREE_SIDE_EFFECTS (node) = 1;
13951   /* Store the location of the operator, for better error report. The
13952      string of the operator will be rebuild based on the OP value. */
13953   EXPR_WFL_LINECOL (node) = op_location;
13954   return node;
13955 }
13956
13957 /* Build an incomplete cast operator, based on the use of the
13958    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
13959    set. java_complete_tree is trained to walk a CONVERT_EXPR even
13960    though its type is already set.  */
13961
13962 static tree
13963 build_cast (int location, tree type, tree exp)
13964 {
13965   tree node = build1 (CONVERT_EXPR, type, exp);
13966   EXPR_WFL_LINECOL (node) = location;
13967   return node;
13968 }
13969
13970 /* Build an incomplete class reference operator.  */
13971 static tree
13972 build_incomplete_class_ref (int location, tree class_name)
13973 {
13974   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
13975   tree class_decl = GET_CPC ();
13976   tree this_class = TREE_TYPE (class_decl);
13977
13978   /* Generate the synthetic static method `class$'.  (Previously we
13979      deferred this, causing different method tables to be emitted
13980      for native code and bytecode.)  */
13981   if (!TYPE_DOT_CLASS (this_class)
13982       && !JPRIMITIVE_TYPE_P (class_name)
13983       && !(TREE_CODE (class_name) == VOID_TYPE))
13984     {
13985       tree target_class;
13986
13987       if (CLASS_INTERFACE (TYPE_NAME (this_class)))
13988         {
13989           /* For interfaces, adding a static 'class$' method directly
13990              is illegal.  So create an inner class to contain the new
13991              method.  Empirically this matches the behavior of javac.  */
13992           tree t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
13993           tree inner = create_anonymous_class (0, t);
13994           target_class = TREE_TYPE (inner);
13995           end_class_declaration (1);
13996         }
13997       else
13998         {
13999           /* For inner classes, add a 'class$' method to their outermost
14000              context, creating it if necessary.  */
14001           while (INNER_CLASS_DECL_P (class_decl))
14002             class_decl = DECL_CONTEXT (class_decl);
14003           target_class = TREE_TYPE (class_decl);
14004         }
14005
14006       if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
14007         build_dot_class_method (target_class);
14008
14009       if (this_class != target_class)
14010         TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
14011     }
14012
14013   EXPR_WFL_LINECOL (node) = location;
14014   return node;
14015 }
14016
14017 /* Complete an incomplete class reference operator.  */
14018 static tree
14019 patch_incomplete_class_ref (tree node)
14020 {
14021   tree type = TREE_OPERAND (node, 0);
14022   tree ref_type;
14023
14024   if (!(ref_type = resolve_type_during_patch (type)))
14025     return error_mark_node;
14026
14027   /* If we're not emitting class files and we know ref_type is a
14028      compiled class, build a direct reference.  */
14029   if ((! flag_emit_class_files && is_compiled_class (ref_type))
14030       || JPRIMITIVE_TYPE_P (ref_type)
14031       || TREE_CODE (ref_type) == VOID_TYPE)
14032     {
14033       tree dot = build_class_ref (ref_type);
14034       /* A class referenced by `foo.class' is initialized.  */
14035       if (!flag_emit_class_files)
14036        dot = build_class_init (ref_type, dot);
14037       return java_complete_tree (dot);
14038     }
14039
14040   /* If we're emitting class files and we have to deal with non
14041      primitive types, we invoke the synthetic static method `class$'.  */
14042   ref_type = build_dot_class_method_invocation (current_class, ref_type);
14043   return java_complete_tree (ref_type);
14044 }
14045
14046 /* 15.14 Unary operators. We return error_mark_node in case of error,
14047    but preserve the type of NODE if the type is fixed.  */
14048
14049 static tree
14050 patch_unaryop (tree node, tree wfl_op)
14051 {
14052   tree op = TREE_OPERAND (node, 0);
14053   tree op_type = TREE_TYPE (op);
14054   tree prom_type = NULL_TREE, value, decl;
14055   int outer_field_flag = 0;
14056   int code = TREE_CODE (node);
14057   int error_found = 0;
14058
14059   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14060
14061   switch (code)
14062     {
14063       /* 15.13.2 Postfix Increment Operator ++ */
14064     case POSTINCREMENT_EXPR:
14065       /* 15.13.3 Postfix Increment Operator -- */
14066     case POSTDECREMENT_EXPR:
14067       /* 15.14.1 Prefix Increment Operator ++ */
14068     case PREINCREMENT_EXPR:
14069       /* 15.14.2 Prefix Decrement Operator -- */
14070     case PREDECREMENT_EXPR:
14071       op = decl = strip_out_static_field_access_decl (op);
14072       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14073       /* We might be trying to change an outer field accessed using
14074          access method. */
14075       if (outer_field_flag)
14076         {
14077           /* Retrieve the decl of the field we're trying to access. We
14078              do that by first retrieving the function we would call to
14079              access the field. It has been already verified that this
14080              field isn't final */
14081           if (flag_emit_class_files)
14082             decl = TREE_OPERAND (op, 0);
14083           else
14084             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14085           decl = DECL_FUNCTION_ACCESS_DECL (decl);
14086         }
14087       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14088       else if (!JDECL_P (decl)
14089           && TREE_CODE (decl) != COMPONENT_REF
14090           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14091           && TREE_CODE (decl) != INDIRECT_REF
14092           && !(TREE_CODE (decl) == COMPOUND_EXPR
14093                && TREE_OPERAND (decl, 1)
14094                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14095         {
14096           TREE_TYPE (node) = error_mark_node;
14097           error_found = 1;
14098         }
14099
14100       /* From now on, we know that op if a variable and that it has a
14101          valid wfl. We use wfl_op to locate errors related to the
14102          ++/-- operand. */
14103       if (!JNUMERIC_TYPE_P (op_type))
14104         {
14105           parse_error_context
14106             (wfl_op, "Invalid argument type `%s' to `%s'",
14107              lang_printable_name (op_type, 0), operator_string (node));
14108           TREE_TYPE (node) = error_mark_node;
14109           error_found = 1;
14110         }
14111       else
14112         {
14113           /* Before the addition, binary numeric promotion is performed on
14114              both operands, if really necessary */
14115           if (JINTEGRAL_TYPE_P (op_type))
14116             {
14117               value = build_int_2 (1, 0);
14118               TREE_TYPE (value) = TREE_TYPE (node) = op_type;
14119             }
14120           else
14121             {
14122               value = build_int_2 (1, 0);
14123               TREE_TYPE (node) =
14124                 binary_numeric_promotion (op_type,
14125                                           TREE_TYPE (value), &op, &value);
14126             }
14127
14128           /* We remember we might be accessing an outer field */
14129           if (outer_field_flag)
14130             {
14131               /* We re-generate an access to the field */
14132               value = build (PLUS_EXPR, TREE_TYPE (op),
14133                              build_outer_field_access (wfl_op, decl), value);
14134
14135               /* And we patch the original access$() into a write
14136                  with plus_op as a rhs */
14137               return outer_field_access_fix (node, op, value);
14138             }
14139
14140           /* And write back into the node. */
14141           TREE_OPERAND (node, 0) = op;
14142           TREE_OPERAND (node, 1) = value;
14143           /* Convert the overall back into its original type, if
14144              necessary, and return */
14145           if (JINTEGRAL_TYPE_P (op_type))
14146             return fold (node);
14147           else
14148             return fold (convert (op_type, node));
14149         }
14150       break;
14151
14152       /* 15.14.3 Unary Plus Operator + */
14153     case UNARY_PLUS_EXPR:
14154       /* 15.14.4 Unary Minus Operator - */
14155     case NEGATE_EXPR:
14156       if (!JNUMERIC_TYPE_P (op_type))
14157         {
14158           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14159           TREE_TYPE (node) = error_mark_node;
14160           error_found = 1;
14161         }
14162       /* Unary numeric promotion is performed on operand */
14163       else
14164         {
14165           op = do_unary_numeric_promotion (op);
14166           prom_type = TREE_TYPE (op);
14167           if (code == UNARY_PLUS_EXPR)
14168             return fold (op);
14169         }
14170       break;
14171
14172       /* 15.14.5 Bitwise Complement Operator ~ */
14173     case BIT_NOT_EXPR:
14174       if (!JINTEGRAL_TYPE_P (op_type))
14175         {
14176           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14177           TREE_TYPE (node) = error_mark_node;
14178           error_found = 1;
14179         }
14180       else
14181         {
14182           op = do_unary_numeric_promotion (op);
14183           prom_type = TREE_TYPE (op);
14184         }
14185       break;
14186
14187       /* 15.14.6 Logical Complement Operator ! */
14188     case TRUTH_NOT_EXPR:
14189       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14190         {
14191           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14192           /* But the type is known. We will report an error if further
14193              attempt of a assignment is made with this rhs */
14194           TREE_TYPE (node) = boolean_type_node;
14195           error_found = 1;
14196         }
14197       else
14198         prom_type = boolean_type_node;
14199       break;
14200
14201       /* 15.15 Cast Expression */
14202     case CONVERT_EXPR:
14203       value = patch_cast (node, wfl_operator);
14204       if (value == error_mark_node)
14205         {
14206           /* If this cast is part of an assignment, we tell the code
14207              that deals with it not to complain about a mismatch,
14208              because things have been cast, anyways */
14209           TREE_TYPE (node) = error_mark_node;
14210           error_found = 1;
14211         }
14212       else
14213         {
14214           value = fold (value);
14215           TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
14216           return value;
14217         }
14218       break;
14219     }
14220
14221   if (error_found)
14222     return error_mark_node;
14223
14224   /* There are cases where node has been replaced by something else
14225      and we don't end up returning here: UNARY_PLUS_EXPR,
14226      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14227   TREE_OPERAND (node, 0) = fold (op);
14228   TREE_TYPE (node) = prom_type;
14229   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14230   return fold (node);
14231 }
14232
14233 /* Generic type resolution that sometimes takes place during node
14234    patching. Returned the resolved type or generate an error
14235    message. Return the resolved type or NULL_TREE.  */
14236
14237 static tree
14238 resolve_type_during_patch (tree type)
14239 {
14240   if (unresolved_type_p (type, NULL))
14241     {
14242       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14243       if (!type_decl)
14244         {
14245           parse_error_context (type,
14246                                "Class `%s' not found in type declaration",
14247                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14248           return NULL_TREE;
14249         }
14250
14251       check_deprecation (type, type_decl);
14252
14253       return TREE_TYPE (type_decl);
14254     }
14255   return type;
14256 }
14257
14258 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14259    found. Otherwise NODE or something meant to replace it is returned.  */
14260
14261 static tree
14262 patch_cast (tree node, tree wfl_op)
14263 {
14264   tree op = TREE_OPERAND (node, 0);
14265   tree cast_type = TREE_TYPE (node);
14266   tree patched, op_type;
14267   char *t1;
14268
14269   /* Some string patching might be necessary at this stage */
14270   if ((patched = patch_string (op)))
14271     TREE_OPERAND (node, 0) = op = patched;
14272   op_type = TREE_TYPE (op);
14273
14274   /* First resolve OP_TYPE if unresolved */
14275   if (!(cast_type = resolve_type_during_patch (cast_type)))
14276     return error_mark_node;
14277
14278   /* Check on cast that are proven correct at compile time */
14279   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14280     {
14281       /* Same type */
14282       if (cast_type == op_type)
14283         return node;
14284
14285       /* A narrowing conversion from a floating-point number to an
14286          integral type requires special handling (5.1.3).  */
14287       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14288         if (cast_type != long_type_node)
14289           op = convert (integer_type_node, op);
14290
14291       /* Try widening/narrowing conversion.  Potentially, things need
14292          to be worked out in gcc so we implement the extreme cases
14293          correctly.  fold_convert() needs to be fixed.  */
14294       return convert (cast_type, op);
14295     }
14296
14297   /* It's also valid to cast a boolean into a boolean */
14298   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14299     return node;
14300
14301   /* null can be casted to references */
14302   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14303     return build_null_of_type (cast_type);
14304
14305   /* The remaining legal casts involve conversion between reference
14306      types. Check for their compile time correctness. */
14307   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14308       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14309     {
14310       TREE_TYPE (node) = promote_type (cast_type);
14311       /* Now, the case can be determined correct at compile time if
14312          OP_TYPE can be converted into CAST_TYPE by assignment
14313          conversion (5.2) */
14314
14315       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14316         {
14317           TREE_SET_CODE (node, NOP_EXPR);
14318           return node;
14319         }
14320
14321       if (flag_emit_class_files)
14322         {
14323           TREE_SET_CODE (node, CONVERT_EXPR);
14324           return node;
14325         }
14326
14327       /* The cast requires a run-time check */
14328       return build (CALL_EXPR, promote_type (cast_type),
14329                     build_address_of (soft_checkcast_node),
14330                     tree_cons (NULL_TREE, build_class_ref (cast_type),
14331                                build_tree_list (NULL_TREE, op)),
14332                     NULL_TREE);
14333     }
14334
14335   /* Any other casts are proven incorrect at compile time */
14336   t1 = xstrdup (lang_printable_name (op_type, 0));
14337   parse_error_context (wfl_op, "Invalid cast from `%s' to `%s'",
14338                        t1, lang_printable_name (cast_type, 0));
14339   free (t1);
14340   return error_mark_node;
14341 }
14342
14343 /* Build a null constant and give it the type TYPE.  */
14344
14345 static tree
14346 build_null_of_type (tree type)
14347 {
14348   tree node = build_int_2 (0, 0);
14349   TREE_TYPE (node) = promote_type (type);
14350   return node;
14351 }
14352
14353 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14354    a list of indices. */
14355 static tree
14356 build_array_ref (int location, tree array, tree index)
14357 {
14358   tree node = build (ARRAY_REF, NULL_TREE, array, index);
14359   EXPR_WFL_LINECOL (node) = location;
14360   return node;
14361 }
14362
14363 /* 15.12 Array Access Expression */
14364
14365 static tree
14366 patch_array_ref (tree node)
14367 {
14368   tree array = TREE_OPERAND (node, 0);
14369   tree array_type  = TREE_TYPE (array);
14370   tree index = TREE_OPERAND (node, 1);
14371   tree index_type = TREE_TYPE (index);
14372   int error_found = 0;
14373
14374   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14375
14376   if (TREE_CODE (array_type) == POINTER_TYPE)
14377     array_type = TREE_TYPE (array_type);
14378
14379   /* The array reference must be an array */
14380   if (!TYPE_ARRAY_P (array_type))
14381     {
14382       parse_error_context
14383         (wfl_operator,
14384          "`[]' can only be applied to arrays. It can't be applied to `%s'",
14385          lang_printable_name (array_type, 0));
14386       TREE_TYPE (node) = error_mark_node;
14387       error_found = 1;
14388     }
14389
14390   /* The array index undergoes unary numeric promotion. The promoted
14391      type must be int */
14392   index = do_unary_numeric_promotion (index);
14393   if (TREE_TYPE (index) != int_type_node)
14394     {
14395       if (valid_cast_to_p (index_type, int_type_node))
14396         parse_error_context (wfl_operator,
14397    "Incompatible type for `[]'. Explicit cast needed to convert `%s' to `int'",
14398                              lang_printable_name (index_type, 0));
14399       else
14400         parse_error_context (wfl_operator,
14401           "Incompatible type for `[]'. Can't convert `%s' to `int'",
14402                              lang_printable_name (index_type, 0));
14403       TREE_TYPE (node) = error_mark_node;
14404       error_found = 1;
14405     }
14406
14407   if (error_found)
14408     return error_mark_node;
14409
14410   array_type = TYPE_ARRAY_ELEMENT (array_type);
14411
14412   if (flag_emit_class_files || flag_emit_xref)
14413     {
14414       TREE_OPERAND (node, 0) = array;
14415       TREE_OPERAND (node, 1) = index;
14416     }
14417   else
14418     node = build_java_arrayaccess (array, array_type, index);
14419   TREE_TYPE (node) = array_type;
14420   return node;
14421 }
14422
14423 /* 15.9 Array Creation Expressions */
14424
14425 static tree
14426 build_newarray_node (tree type, tree dims, int extra_dims)
14427 {
14428   tree node =
14429     build (NEW_ARRAY_EXPR, NULL_TREE, type, nreverse (dims),
14430            build_int_2 (extra_dims, 0));
14431   return node;
14432 }
14433
14434 static tree
14435 patch_newarray (tree node)
14436 {
14437   tree type = TREE_OPERAND (node, 0);
14438   tree dims = TREE_OPERAND (node, 1);
14439   tree cdim, array_type;
14440   int error_found = 0;
14441   int ndims = 0;
14442   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14443
14444   /* Dimension types are verified. It's better for the types to be
14445      verified in order. */
14446   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14447     {
14448       int dim_error = 0;
14449       tree dim = TREE_VALUE (cdim);
14450
14451       /* Dim might have been saved during its evaluation */
14452       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14453
14454       /* The type of each specified dimension must be an integral type. */
14455       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14456         dim_error = 1;
14457
14458       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14459          promoted type must be int. */
14460       else
14461         {
14462           dim = do_unary_numeric_promotion (dim);
14463           if (TREE_TYPE (dim) != int_type_node)
14464             dim_error = 1;
14465         }
14466
14467       /* Report errors on types here */
14468       if (dim_error)
14469         {
14470           parse_error_context
14471             (TREE_PURPOSE (cdim),
14472              "Incompatible type for dimension in array creation expression. %s convert `%s' to `int'",
14473              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14474               "Explicit cast needed to" : "Can't"),
14475              lang_printable_name (TREE_TYPE (dim), 0));
14476           error_found = 1;
14477         }
14478
14479       TREE_PURPOSE (cdim) = NULL_TREE;
14480     }
14481
14482   /* Resolve array base type if unresolved */
14483   if (!(type = resolve_type_during_patch (type)))
14484     error_found = 1;
14485
14486   if (error_found)
14487     {
14488       /* We don't want further evaluation of this bogus array creation
14489          operation */
14490       TREE_TYPE (node) = error_mark_node;
14491       return error_mark_node;
14492     }
14493
14494   /* Set array_type to the actual (promoted) array type of the result. */
14495   if (TREE_CODE (type) == RECORD_TYPE)
14496     type = build_pointer_type (type);
14497   while (--xdims >= 0)
14498     {
14499       type = promote_type (build_java_array_type (type, -1));
14500     }
14501   dims = nreverse (dims);
14502   array_type = type;
14503   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14504     {
14505       type = array_type;
14506       array_type
14507         = build_java_array_type (type,
14508                                  TREE_CODE (cdim) == INTEGER_CST
14509                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14510                                  : -1);
14511       array_type = promote_type (array_type);
14512     }
14513   dims = nreverse (dims);
14514
14515   /* The node is transformed into a function call. Things are done
14516      differently according to the number of dimensions. If the number
14517      of dimension is equal to 1, then the nature of the base type
14518      (primitive or not) matters. */
14519   if (ndims == 1)
14520     return build_new_array (type, TREE_VALUE (dims));
14521
14522   /* Can't reuse what's already written in expr.c because it uses the
14523      JVM stack representation. Provide a build_multianewarray. FIXME */
14524   return build (CALL_EXPR, array_type,
14525                 build_address_of (soft_multianewarray_node),
14526                 tree_cons (NULL_TREE, build_class_ref (TREE_TYPE (array_type)),
14527                            tree_cons (NULL_TREE,
14528                                       build_int_2 (ndims, 0), dims )),
14529                 NULL_TREE);
14530 }
14531
14532 /* 10.6 Array initializer.  */
14533
14534 /* Build a wfl for array element that don't have one, so we can
14535    pin-point errors.  */
14536
14537 static tree
14538 maybe_build_array_element_wfl (tree node)
14539 {
14540   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14541     return build_expr_wfl (NULL_TREE, ctxp->filename,
14542                            ctxp->elc.line, ctxp->elc.prev_col);
14543   else
14544     return NULL_TREE;
14545 }
14546
14547 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14548    identification of initialized arrays easier to detect during walk
14549    and expansion.  */
14550
14551 static tree
14552 build_new_array_init (int location, tree values)
14553 {
14554   tree constructor = build_constructor (NULL_TREE, values);
14555   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14556   EXPR_WFL_LINECOL (to_return) = location;
14557   return to_return;
14558 }
14559
14560 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14561    occurred.  Otherwise return NODE after having set its type
14562    appropriately.  */
14563
14564 static tree
14565 patch_new_array_init (tree type, tree node)
14566 {
14567   int error_seen = 0;
14568   tree current, element_type;
14569   HOST_WIDE_INT length;
14570   int all_constant = 1;
14571   tree init = TREE_OPERAND (node, 0);
14572
14573   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14574     {
14575       parse_error_context (node,
14576                            "Invalid array initializer for non-array type `%s'",
14577                            lang_printable_name (type, 1));
14578       return error_mark_node;
14579     }
14580   type = TREE_TYPE (type);
14581   element_type = TYPE_ARRAY_ELEMENT (type);
14582
14583   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14584
14585   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14586        current;  length++, current = TREE_CHAIN (current))
14587     {
14588       tree elt = TREE_VALUE (current);
14589       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14590         {
14591           error_seen |= array_constructor_check_entry (element_type, current);
14592           elt = TREE_VALUE (current);
14593           /* When compiling to native code, STRING_CST is converted to
14594              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14595           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14596             all_constant = 0;
14597         }
14598       else
14599         {
14600           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14601           TREE_PURPOSE (current) = NULL_TREE;
14602           all_constant = 0;
14603         }
14604       if (elt && TREE_CODE (elt) == TREE_LIST
14605           && TREE_VALUE (elt) == error_mark_node)
14606         error_seen = 1;
14607     }
14608
14609   if (error_seen)
14610     return error_mark_node;
14611
14612   /* Create a new type. We can't reuse the one we have here by
14613      patching its dimension because it originally is of dimension -1
14614      hence reused by gcc. This would prevent triangular arrays. */
14615   type = build_java_array_type (element_type, length);
14616   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14617   TREE_TYPE (node) = promote_type (type);
14618   TREE_CONSTANT (init) = all_constant;
14619   TREE_CONSTANT (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 = empty_stmt_node;
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   if (TREE_CODE (expression) == INTEGER_CST)
14818     {
14819       if (integer_zerop (expression))
14820         node = TREE_OPERAND (node, 2);
14821       else
14822         node = TREE_OPERAND (node, 1);
14823       if (CAN_COMPLETE_NORMALLY (node) != can_complete_normally)
14824         {
14825           node = build (COMPOUND_EXPR, void_type_node, node, empty_stmt_node);
14826           CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14827         }
14828       return node;
14829     }
14830   TREE_TYPE (node) = void_type_node;
14831   TREE_SIDE_EFFECTS (node) = 1;
14832   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14833   return node;
14834 }
14835
14836 /* 14.6 Labeled Statements */
14837
14838 /* Action taken when a labeled statement is parsed. a new
14839    LABELED_BLOCK_EXPR is created. No statement is attached to the
14840    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14841
14842 static tree
14843 build_labeled_block (int location, tree label)
14844 {
14845   tree label_name ;
14846   tree label_decl, node;
14847   if (label == NULL_TREE || label == continue_identifier_node)
14848     label_name = label;
14849   else
14850     {
14851       label_name = merge_qualified_name (label_id, label);
14852       /* Issue an error if we try to reuse a label that was previously
14853          declared */
14854       if (IDENTIFIER_LOCAL_VALUE (label_name))
14855         {
14856           EXPR_WFL_LINECOL (wfl_operator) = location;
14857           parse_error_context (wfl_operator,
14858             "Declaration of `%s' shadows a previous label declaration",
14859                                IDENTIFIER_POINTER (label));
14860           EXPR_WFL_LINECOL (wfl_operator) =
14861             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14862           parse_error_context (wfl_operator,
14863             "This is the location of the previous declaration of label `%s'",
14864                                IDENTIFIER_POINTER (label));
14865           java_error_count--;
14866         }
14867     }
14868
14869   label_decl = create_label_decl (label_name);
14870   node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14871   EXPR_WFL_LINECOL (node) = location;
14872   TREE_SIDE_EFFECTS (node) = 1;
14873   return node;
14874 }
14875
14876 /* A labeled statement LBE is attached a statement.  */
14877
14878 static tree
14879 finish_labeled_statement (tree lbe, /* Labeled block expr */
14880                           tree statement)
14881 {
14882   /* In anyways, tie the loop to its statement */
14883   LABELED_BLOCK_BODY (lbe) = statement;
14884   pop_labeled_block ();
14885   POP_LABELED_BLOCK ();
14886   return lbe;
14887 }
14888
14889 /* 14.10, 14.11, 14.12 Loop Statements */
14890
14891 /* Create an empty LOOP_EXPR and make it the last in the nested loop
14892    list. */
14893
14894 static tree
14895 build_new_loop (tree loop_body)
14896 {
14897   tree loop =  build (LOOP_EXPR, NULL_TREE, loop_body);
14898   TREE_SIDE_EFFECTS (loop) = 1;
14899   PUSH_LOOP (loop);
14900   return loop;
14901 }
14902
14903 /* Create a loop body according to the following structure:
14904      COMPOUND_EXPR
14905        COMPOUND_EXPR            (loop main body)
14906          EXIT_EXPR              (this order is for while/for loops.
14907          LABELED_BLOCK_EXPR      the order is reversed for do loops)
14908            LABEL_DECL           (a continue occurring here branches at the
14909            BODY                  end of this labeled block)
14910        INCREMENT                (if any)
14911
14912   REVERSED, if nonzero, tells that the loop condition expr comes
14913   after the body, like in the do-while loop.
14914
14915   To obtain a loop, the loop body structure described above is
14916   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
14917
14918    LABELED_BLOCK_EXPR
14919      LABEL_DECL                   (use this label to exit the loop)
14920      LOOP_EXPR
14921        <structure described above> */
14922
14923 static tree
14924 build_loop_body (int location, tree condition, int reversed)
14925 {
14926   tree first, second, body;
14927
14928   condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
14929   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
14930   condition = build_debugable_stmt (location, condition);
14931   TREE_SIDE_EFFECTS (condition) = 1;
14932
14933   body = build_labeled_block (0, continue_identifier_node);
14934   first = (reversed ? body : condition);
14935   second = (reversed ? condition : body);
14936   return
14937     build (COMPOUND_EXPR, NULL_TREE,
14938            build (COMPOUND_EXPR, NULL_TREE, first, second), empty_stmt_node);
14939 }
14940
14941 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
14942    their order) on the current loop. Unlink the current loop from the
14943    loop list.  */
14944
14945 static tree
14946 finish_loop_body (int location, tree condition, tree body, int reversed)
14947 {
14948   tree to_return = ctxp->current_loop;
14949   tree loop_body = LOOP_EXPR_BODY (to_return);
14950   if (condition)
14951     {
14952       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
14953       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
14954          The real EXIT_EXPR is one operand further. */
14955       EXPR_WFL_LINECOL (cnode) = location;
14956       /* This one is for accurate error reports */
14957       EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
14958       TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
14959     }
14960   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
14961   POP_LOOP ();
14962   return to_return;
14963 }
14964
14965 /* Tailored version of finish_loop_body for FOR loops, when FOR
14966    loops feature the condition part */
14967
14968 static tree
14969 finish_for_loop (int location, tree condition, tree update, tree body)
14970 {
14971   /* Put the condition and the loop body in place */
14972   tree loop = finish_loop_body (location, condition, body, 0);
14973   /* LOOP is the current loop which has been now popped of the loop
14974      stack.  Mark the update block as reachable and install it.  We do
14975      this because the (current interpretation of the) JLS requires
14976      that the update expression be considered reachable even if the
14977      for loop's body doesn't complete normally.  */
14978   if (update != NULL_TREE && update != empty_stmt_node)
14979     {
14980       tree up2 = update;
14981       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
14982         up2 = EXPR_WFL_NODE (up2);
14983       /* It is possible for the update expression to be an
14984          EXPR_WFL_NODE wrapping nothing.  */
14985       if (up2 != NULL_TREE && up2 != empty_stmt_node)
14986         {
14987           /* Try to detect constraint violations.  These would be
14988              programming errors somewhere.  */
14989           if (! IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (up2)))
14990               || TREE_CODE (up2) == LOOP_EXPR)
14991             abort ();
14992           SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
14993         }
14994     }
14995   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
14996   return loop;
14997 }
14998
14999 /* Try to find the loop a block might be related to. This comprises
15000    the case where the LOOP_EXPR is found as the second operand of a
15001    COMPOUND_EXPR, because the loop happens to have an initialization
15002    part, then expressed as the first operand of the COMPOUND_EXPR. If
15003    the search finds something, 1 is returned. Otherwise, 0 is
15004    returned. The search is assumed to start from a
15005    LABELED_BLOCK_EXPR's block.  */
15006
15007 static tree
15008 search_loop (tree statement)
15009 {
15010   if (TREE_CODE (statement) == LOOP_EXPR)
15011     return statement;
15012
15013   if (TREE_CODE (statement) == BLOCK)
15014     statement = BLOCK_SUBBLOCKS (statement);
15015   else
15016     return NULL_TREE;
15017
15018   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15019     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15020       statement = TREE_OPERAND (statement, 1);
15021
15022   return (TREE_CODE (statement) == LOOP_EXPR
15023           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
15024 }
15025
15026 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15027    returned otherwise.  */
15028
15029 static int
15030 labeled_block_contains_loop_p (tree block, tree loop)
15031 {
15032   if (!block)
15033     return 0;
15034
15035   if (LABELED_BLOCK_BODY (block) == loop)
15036     return 1;
15037
15038   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
15039     return 1;
15040
15041   return 0;
15042 }
15043
15044 /* If the loop isn't surrounded by a labeled statement, create one and
15045    insert LOOP as its body.  */
15046
15047 static tree
15048 patch_loop_statement (tree loop)
15049 {
15050   tree loop_label;
15051
15052   TREE_TYPE (loop) = void_type_node;
15053   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
15054     return loop;
15055
15056   loop_label = build_labeled_block (0, NULL_TREE);
15057   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15058      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15059   LABELED_BLOCK_BODY (loop_label) = loop;
15060   PUSH_LABELED_BLOCK (loop_label);
15061   return loop_label;
15062 }
15063
15064 /* 14.13, 14.14: break and continue Statements */
15065
15066 /* Build a break or a continue statement. a null NAME indicates an
15067    unlabeled break/continue statement.  */
15068
15069 static tree
15070 build_bc_statement (int location, int is_break, tree name)
15071 {
15072   tree break_continue, label_block_expr = NULL_TREE;
15073
15074   if (name)
15075     {
15076       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15077             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15078         /* Null means that we don't have a target for this named
15079            break/continue. In this case, we make the target to be the
15080            label name, so that the error can be reported accurately in
15081            patch_bc_statement. */
15082         label_block_expr = EXPR_WFL_NODE (name);
15083     }
15084   /* Unlabeled break/continue will be handled during the
15085      break/continue patch operation */
15086   break_continue
15087     = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
15088
15089   IS_BREAK_STMT_P (break_continue) = is_break;
15090   TREE_SIDE_EFFECTS (break_continue) = 1;
15091   EXPR_WFL_LINECOL (break_continue) = location;
15092   break_continue = build_debugable_stmt (location, break_continue);
15093   return break_continue;
15094 }
15095
15096 /* Verification of a break/continue statement. */
15097
15098 static tree
15099 patch_bc_statement (tree node)
15100 {
15101   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15102   tree labeled_block = ctxp->current_labeled_block;
15103   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15104
15105   /* Having an identifier here means that the target is unknown. */
15106   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15107     {
15108       parse_error_context (wfl_operator, "No label definition found for `%s'",
15109                            IDENTIFIER_POINTER (bc_label));
15110       return error_mark_node;
15111     }
15112   if (! IS_BREAK_STMT_P (node))
15113     {
15114       /* It's a continue statement. */
15115       for (;; labeled_block = TREE_CHAIN (labeled_block))
15116         {
15117           if (labeled_block == NULL_TREE)
15118             {
15119               if (bc_label == NULL_TREE)
15120                 parse_error_context (wfl_operator,
15121                                      "`continue' must be in loop");
15122               else
15123                 parse_error_context
15124                   (wfl_operator, "continue label `%s' does not name a loop",
15125                    IDENTIFIER_POINTER (bc_label));
15126               return error_mark_node;
15127             }
15128           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15129                == continue_identifier_node)
15130               && (bc_label == NULL_TREE
15131                   || TREE_CHAIN (labeled_block) == bc_label))
15132             {
15133               bc_label = labeled_block;
15134               break;
15135             }
15136         }
15137     }
15138   else if (!bc_label)
15139     {
15140       for (;; labeled_block = TREE_CHAIN (labeled_block))
15141         {
15142           if (labeled_block == NULL_TREE)
15143             {
15144               parse_error_context (wfl_operator,
15145                                      "`break' must be in loop or switch");
15146               return error_mark_node;
15147             }
15148           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15149           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15150               || search_loop (target_stmt))
15151             {
15152               bc_label = labeled_block;
15153               break;
15154             }
15155         }
15156     }
15157
15158   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15159   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15160
15161   /* Our break/continue don't return values. */
15162   TREE_TYPE (node) = void_type_node;
15163   /* Encapsulate the break within a compound statement so that it's
15164      expanded all the times by expand_expr (and not clobbered
15165      sometimes, like after a if statement) */
15166   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15167   TREE_SIDE_EFFECTS (node) = 1;
15168   return node;
15169 }
15170
15171 /* Process the exit expression belonging to a loop. Its type must be
15172    boolean.  */
15173
15174 static tree
15175 patch_exit_expr (tree node)
15176 {
15177   tree expression = TREE_OPERAND (node, 0);
15178   TREE_TYPE (node) = error_mark_node;
15179   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15180
15181   /* The type of expression must be boolean */
15182   if (TREE_TYPE (expression) != boolean_type_node)
15183     {
15184       parse_error_context
15185         (wfl_operator,
15186     "Incompatible type for loop conditional. Can't convert `%s' to `boolean'",
15187          lang_printable_name (TREE_TYPE (expression), 0));
15188       return error_mark_node;
15189     }
15190   /* Now we know things are allright, invert the condition, fold and
15191      return */
15192   TREE_OPERAND (node, 0) =
15193     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15194
15195   if (! integer_zerop (TREE_OPERAND (node, 0))
15196       && ctxp->current_loop != NULL_TREE
15197       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15198     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15199   if (! integer_onep (TREE_OPERAND (node, 0)))
15200     CAN_COMPLETE_NORMALLY (node) = 1;
15201
15202
15203   TREE_TYPE (node) = void_type_node;
15204   return node;
15205 }
15206
15207 /* 14.9 Switch statement */
15208
15209 static tree
15210 patch_switch_statement (tree node)
15211 {
15212   tree se = TREE_OPERAND (node, 0), se_type;
15213   tree save, iter;
15214
15215   /* Complete the switch expression */
15216   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15217   se_type = TREE_TYPE (se);
15218   /* The type of the switch expression must be char, byte, short or
15219      int */
15220   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15221     {
15222       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15223       parse_error_context (wfl_operator,
15224           "Incompatible type for `switch'. Can't convert `%s' to `int'",
15225                            lang_printable_name (se_type, 0));
15226       /* This is what java_complete_tree will check */
15227       TREE_OPERAND (node, 0) = error_mark_node;
15228       return error_mark_node;
15229     }
15230
15231   /* Save and restore the outer case label list.  */
15232   save = case_label_list;
15233   case_label_list = NULL_TREE;
15234
15235   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15236
15237   /* See if we've found a duplicate label.  We can't leave this until
15238      code generation, because in `--syntax-only' and `-C' modes we
15239      don't do ordinary code generation.  */
15240   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15241     {
15242       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15243       tree subiter;
15244       for (subiter = TREE_CHAIN (iter);
15245            subiter != NULL_TREE;
15246            subiter = TREE_CHAIN (subiter))
15247         {
15248           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15249           if (val == subval)
15250             {
15251               EXPR_WFL_LINECOL (wfl_operator)
15252                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15253               /* The case_label_list is in reverse order, so print the
15254                  outer label first.  */
15255               parse_error_context (wfl_operator, "duplicate case label: `"
15256                                    HOST_WIDE_INT_PRINT_DEC "'", subval);
15257               EXPR_WFL_LINECOL (wfl_operator)
15258                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15259               parse_error_context (wfl_operator, "original label is here");
15260
15261               break;
15262             }
15263         }
15264     }
15265
15266   case_label_list = save;
15267
15268   /* Ready to return */
15269   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15270     {
15271       TREE_TYPE (node) = error_mark_node;
15272       return error_mark_node;
15273     }
15274   TREE_TYPE (node) = void_type_node;
15275   TREE_SIDE_EFFECTS (node) = 1;
15276   CAN_COMPLETE_NORMALLY (node)
15277     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15278       || ! SWITCH_HAS_DEFAULT (node);
15279   return node;
15280 }
15281
15282 /* Assertions.  */
15283
15284 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15285    might be NULL_TREE.  */
15286 static tree
15287 build_assertion (int location, tree condition, tree value)
15288 {
15289   tree node;
15290   tree klass = GET_CPC ();
15291
15292   if (! CLASS_USES_ASSERTIONS (klass))
15293     {
15294       tree field, classdollar, id, call;
15295       tree class_type = TREE_TYPE (klass);
15296
15297       field = add_field (class_type,
15298                          get_identifier ("$assertionsDisabled"),
15299                          boolean_type_node,
15300                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15301       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15302       FIELD_SYNTHETIC (field) = 1;
15303
15304       if (!TYPE_DOT_CLASS (class_type))
15305         build_dot_class_method (class_type);
15306       classdollar = build_dot_class_method_invocation (class_type, class_type);
15307
15308       /* Call CLASS.desiredAssertionStatus().  */
15309       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15310       call = build (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15311       call = make_qualified_primary (classdollar, call, location);
15312       TREE_SIDE_EFFECTS (call) = 1;
15313
15314       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15315          seem odd, but we do it to generate code identical to that of
15316          the JDK.  */
15317       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15318       TREE_SIDE_EFFECTS (call) = 1;
15319       DECL_INITIAL (field) = call;
15320
15321       /* Record the initializer in the initializer statement list.  */
15322       call = build (MODIFY_EXPR, NULL_TREE, field, call);
15323       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15324       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15325       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15326
15327       CLASS_USES_ASSERTIONS (klass) = 1;
15328     }
15329
15330   if (value != NULL_TREE)
15331     value = tree_cons (NULL_TREE, value, NULL_TREE);
15332
15333   node = build_wfl_node (get_identifier ("java"));
15334   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15335                               location);
15336   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15337                               location);
15338
15339   node = build (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15340   TREE_SIDE_EFFECTS (node) = 1;
15341   /* It is too early to use BUILD_THROW.  */
15342   node = build1 (THROW_EXPR, NULL_TREE, node);
15343   TREE_SIDE_EFFECTS (node) = 1;
15344
15345   /* We invert the condition; if we just put NODE as the `else' part
15346      then we generate weird-looking bytecode.  */
15347   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15348   /* Check $assertionsDisabled.  */
15349   condition
15350     = build (TRUTH_ANDIF_EXPR, NULL_TREE,
15351              build1 (TRUTH_NOT_EXPR, NULL_TREE,
15352                      build_wfl_node (get_identifier ("$assertionsDisabled"))),
15353              condition);
15354   node = build_if_else_statement (location, condition, node, NULL_TREE);
15355   return node;
15356 }
15357
15358 /* 14.18 The try/catch statements */
15359
15360 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15361    catches TYPE and executes CATCH_STMTS.  */
15362
15363 static tree
15364 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15365                             tree catch_stmts)
15366 {
15367   tree try_block, catch_clause_param, catch_block, catch;
15368
15369   /* First build a try block */
15370   try_block = build_expr_block (try_stmts, NULL_TREE);
15371
15372   /* Build a catch block: we need a catch clause parameter */
15373   if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15374     {
15375       tree catch_type = obtain_incomplete_type (type_or_name);
15376       jdep *dep;
15377       catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15378       register_incomplete_type (JDEP_VARIABLE, type_or_name,
15379                                 catch_clause_param, catch_type);
15380       dep = CLASSD_LAST (ctxp->classd_list);
15381       JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15382     }
15383   else
15384     catch_clause_param = build_decl (VAR_DECL, wpv_id,
15385                                      build_pointer_type (type_or_name));
15386
15387   /* And a block */
15388   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15389
15390   /* Initialize the variable and store in the block */
15391   catch = build (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15392                  build (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15393   add_stmt_to_block (catch_block, NULL_TREE, catch);
15394
15395   /* Add the catch statements */
15396   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15397
15398   /* Now we can build a CATCH_EXPR */
15399   catch_block = build1 (CATCH_EXPR, NULL_TREE, catch_block);
15400
15401   return build_try_statement (location, try_block, catch_block);
15402 }
15403
15404 static tree
15405 build_try_statement (int location, tree try_block, tree catches)
15406 {
15407   tree node = build (TRY_EXPR, NULL_TREE, try_block, catches);
15408   EXPR_WFL_LINECOL (node) = location;
15409   return node;
15410 }
15411
15412 static tree
15413 build_try_finally_statement (int location, tree try_block, tree finally)
15414 {
15415   tree node = build (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15416   EXPR_WFL_LINECOL (node) = location;
15417   return node;
15418 }
15419
15420 static tree
15421 patch_try_statement (tree node)
15422 {
15423   int error_found = 0;
15424   tree try = TREE_OPERAND (node, 0);
15425   /* Exception handlers are considered in left to right order */
15426   tree catch = nreverse (TREE_OPERAND (node, 1));
15427   tree current, caught_type_list = NULL_TREE;
15428
15429   /* Check catch clauses, if any. Every time we find an error, we try
15430      to process the next catch clause. We process the catch clause before
15431      the try block so that when processing the try block we can check thrown
15432      exceptions againts the caught type list. */
15433   for (current = catch; current; current = TREE_CHAIN (current))
15434     {
15435       tree carg_decl, carg_type;
15436       tree sub_current, catch_block, catch_clause;
15437       int unreachable;
15438
15439       /* At this point, the structure of the catch clause is
15440            CATCH_EXPR           (catch node)
15441              BLOCK              (with the decl of the parameter)
15442                COMPOUND_EXPR
15443                  MODIFY_EXPR   (assignment of the catch parameter)
15444                  BLOCK          (catch clause block)
15445        */
15446       catch_clause = TREE_OPERAND (current, 0);
15447       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15448       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15449
15450       /* Catch clauses can't have more than one parameter declared,
15451          but it's already enforced by the grammar. Make sure that the
15452          only parameter of the clause statement in of class Throwable
15453          or a subclass of Throwable, but that was done earlier. The
15454          catch clause parameter type has also been resolved. */
15455
15456       /* Just make sure that the catch clause parameter type inherits
15457          from java.lang.Throwable */
15458       if (!inherits_from_p (carg_type, throwable_type_node))
15459         {
15460           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15461           parse_error_context (wfl_operator,
15462                                "Can't catch class `%s'. Catch clause parameter type must be a subclass of class `java.lang.Throwable'",
15463                                lang_printable_name (carg_type, 0));
15464           error_found = 1;
15465           continue;
15466         }
15467
15468       /* Partial check for unreachable catch statement: The catch
15469          clause is reachable iff is no earlier catch block A in
15470          the try statement such that the type of the catch
15471          clause's parameter is the same as or a subclass of the
15472          type of A's parameter */
15473       unreachable = 0;
15474       for (sub_current = catch;
15475            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15476         {
15477           tree sub_catch_clause, decl;
15478           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15479           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15480
15481           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15482             {
15483               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15484               parse_error_context
15485                 (wfl_operator,
15486                  "`catch' not reached because of the catch clause at line %d",
15487                  EXPR_WFL_LINENO (sub_current));
15488               unreachable = error_found = 1;
15489               break;
15490             }
15491         }
15492       /* Complete the catch clause block */
15493       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15494       if (catch_block == error_mark_node)
15495         {
15496           error_found = 1;
15497           continue;
15498         }
15499       if (CAN_COMPLETE_NORMALLY (catch_block))
15500         CAN_COMPLETE_NORMALLY (node) = 1;
15501       TREE_OPERAND (current, 0) = catch_block;
15502
15503       if (unreachable)
15504         continue;
15505
15506       /* Things to do here: the exception must be thrown */
15507
15508       /* Link this type to the caught type list */
15509       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15510     }
15511
15512   PUSH_EXCEPTIONS (caught_type_list);
15513   if ((try = java_complete_tree (try)) == error_mark_node)
15514     error_found = 1;
15515   if (CAN_COMPLETE_NORMALLY (try))
15516     CAN_COMPLETE_NORMALLY (node) = 1;
15517   POP_EXCEPTIONS ();
15518
15519   /* Verification ends here */
15520   if (error_found)
15521     return error_mark_node;
15522
15523   TREE_OPERAND (node, 0) = try;
15524   TREE_OPERAND (node, 1) = catch;
15525   TREE_TYPE (node) = void_type_node;
15526   return node;
15527 }
15528
15529 /* 14.17 The synchronized Statement */
15530
15531 static tree
15532 patch_synchronized_statement (tree node, tree wfl_op1)
15533 {
15534   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15535   tree block = TREE_OPERAND (node, 1);
15536
15537   tree tmp, enter, exit, expr_decl, assignment;
15538
15539   if (expr == error_mark_node)
15540     {
15541       block = java_complete_tree (block);
15542       return expr;
15543     }
15544
15545   /* We might be trying to synchronize on a STRING_CST */
15546   if ((tmp = patch_string (expr)))
15547     expr = tmp;
15548
15549   /* The TYPE of expr must be a reference type */
15550   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15551     {
15552       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15553       parse_error_context (wfl_operator, "Incompatible type for `synchronized'. Can't convert `%s' to `java.lang.Object'",
15554                            lang_printable_name (TREE_TYPE (expr), 0));
15555       return error_mark_node;
15556     }
15557
15558   if (flag_emit_xref)
15559     {
15560       TREE_OPERAND (node, 0) = expr;
15561       TREE_OPERAND (node, 1) = java_complete_tree (block);
15562       CAN_COMPLETE_NORMALLY (node) = 1;
15563       return node;
15564     }
15565
15566   /* Generate a try-finally for the synchronized statement, except
15567      that the handler that catches all throw exception calls
15568      _Jv_MonitorExit and then rethrow the exception.
15569      The synchronized statement is then implemented as:
15570      TRY
15571        {
15572          _Jv_MonitorEnter (expression)
15573          synchronized_block
15574          _Jv_MonitorExit (expression)
15575        }
15576      CATCH_ALL
15577        {
15578          e = _Jv_exception_info ();
15579          _Jv_MonitorExit (expression)
15580          Throw (e);
15581        } */
15582
15583   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15584   BUILD_MONITOR_ENTER (enter, expr_decl);
15585   BUILD_MONITOR_EXIT (exit, expr_decl);
15586   CAN_COMPLETE_NORMALLY (enter) = 1;
15587   CAN_COMPLETE_NORMALLY (exit) = 1;
15588   assignment = build (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15589   TREE_SIDE_EFFECTS (assignment) = 1;
15590   node = build (COMPOUND_EXPR, NULL_TREE,
15591                 build (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15592                 build (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15593   node = build_expr_block (node, expr_decl);
15594
15595   return java_complete_tree (node);
15596 }
15597
15598 /* 14.16 The throw Statement */
15599
15600 static tree
15601 patch_throw_statement (tree node, tree wfl_op1)
15602 {
15603   tree expr = TREE_OPERAND (node, 0);
15604   tree type = TREE_TYPE (expr);
15605   int unchecked_ok = 0, tryblock_throws_ok = 0;
15606
15607   /* Thrown expression must be assignable to java.lang.Throwable */
15608   if (!try_reference_assignconv (throwable_type_node, expr))
15609     {
15610       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15611       parse_error_context (wfl_operator,
15612     "Can't throw `%s'; it must be a subclass of class `java.lang.Throwable'",
15613                            lang_printable_name (type, 0));
15614       /* If the thrown expression was a reference, we further the
15615          compile-time check. */
15616       if (!JREFERENCE_TYPE_P (type))
15617         return error_mark_node;
15618     }
15619
15620   /* At least one of the following must be true */
15621
15622   /* The type of the throw expression is a not checked exception,
15623      i.e. is a unchecked expression. */
15624   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15625
15626   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15627   /* An instance can't throw a checked exception unless that exception
15628      is explicitly declared in the `throws' clause of each
15629      constructor. This doesn't apply to anonymous classes, since they
15630      don't have declared constructors. */
15631   if (!unchecked_ok
15632       && DECL_INSTINIT_P (current_function_decl)
15633       && !ANONYMOUS_CLASS_P (current_class))
15634     {
15635       tree current;
15636       for (current = TYPE_METHODS (current_class); current;
15637            current = TREE_CHAIN (current))
15638         if (DECL_CONSTRUCTOR_P (current)
15639             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15640           {
15641             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)",
15642                                  lang_printable_name (TREE_TYPE (expr), 0));
15643             return error_mark_node;
15644           }
15645     }
15646
15647   /* Throw is contained in a try statement and at least one catch
15648      clause can receive the thrown expression or the current method is
15649      declared to throw such an exception. Or, the throw statement is
15650      contained in a method or constructor declaration and the type of
15651      the Expression is assignable to at least one type listed in the
15652      throws clause the declaration. */
15653   if (!unchecked_ok)
15654     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15655   if (!(unchecked_ok || tryblock_throws_ok))
15656     {
15657       /* If there is a surrounding try block that has no matching
15658          clatch clause, report it first. A surrounding try block exits
15659          only if there is something after the list of checked
15660          exception thrown by the current function (if any). */
15661       if (IN_TRY_BLOCK_P ())
15662         parse_error_context (wfl_operator, "Checked exception `%s' can't be caught by any of the catch clause(s) of the surrounding `try' block",
15663                              lang_printable_name (type, 0));
15664       /* If we have no surrounding try statement and the method doesn't have
15665          any throws, report it now. FIXME */
15666
15667       /* We report that the exception can't be throw from a try block
15668          in all circumstances but when the `throw' is inside a static
15669          block. */
15670       else if (!EXCEPTIONS_P (currently_caught_type_list)
15671                && !tryblock_throws_ok)
15672         {
15673           if (DECL_CLINIT_P (current_function_decl))
15674             parse_error_context (wfl_operator,
15675                    "Checked exception `%s' can't be thrown in initializer",
15676                                  lang_printable_name (type, 0));
15677           else
15678             parse_error_context (wfl_operator,
15679                    "Checked exception `%s' isn't thrown from a `try' block",
15680                                  lang_printable_name (type, 0));
15681         }
15682       /* Otherwise, the current method doesn't have the appropriate
15683          throws declaration */
15684       else
15685         parse_error_context (wfl_operator, "Checked exception `%s' doesn't match any of current method's `throws' declaration(s)",
15686                              lang_printable_name (type, 0));
15687       return error_mark_node;
15688     }
15689
15690   if (! flag_emit_class_files && ! flag_emit_xref)
15691     BUILD_THROW (node, expr);
15692
15693   /* If doing xrefs, keep the location where the `throw' was seen. */
15694   if (flag_emit_xref)
15695     EXPR_WFL_LINECOL (node) = EXPR_WFL_LINECOL (wfl_op1);
15696   return node;
15697 }
15698
15699 /* Check that exception said to be thrown by method DECL can be
15700    effectively caught from where DECL is invoked.  THIS_EXPR is the
15701    expression that computes `this' for the method call.  */
15702 static void
15703 check_thrown_exceptions (int location, tree decl, tree this_expr)
15704 {
15705   tree throws;
15706   int is_array_call = 0;
15707
15708   /* Skip check within generated methods, such as access$<n>.  */
15709   if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
15710     return;
15711
15712   if (this_expr != NULL_TREE
15713       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15714       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15715     is_array_call = 1;
15716
15717   /* For all the unchecked exceptions thrown by DECL.  */
15718   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15719        throws = TREE_CHAIN (throws))
15720     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15721       {
15722         /* Suppress errors about cloning arrays.  */
15723         if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15724           continue;
15725
15726         EXPR_WFL_LINECOL (wfl_operator) = location;
15727         if (DECL_FINIT_P (current_function_decl))
15728           parse_error_context
15729             (wfl_operator, "Exception `%s' can't be thrown in initializer",
15730              lang_printable_name (TREE_VALUE (throws), 0));
15731         else
15732           {
15733             parse_error_context
15734               (wfl_operator, "Exception `%s' must be caught, or it must be declared in the `throws' clause of `%s'",
15735                lang_printable_name (TREE_VALUE (throws), 0),
15736                (DECL_INIT_P (current_function_decl) ?
15737                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15738                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15739           }
15740       }
15741 }
15742
15743 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15744    try-catch blocks, OR is listed in the `throws' clause of the
15745    current method.  */
15746
15747 static int
15748 check_thrown_exceptions_do (tree exception)
15749 {
15750   tree list = currently_caught_type_list;
15751   resolve_and_layout (exception, NULL_TREE);
15752   /* First, all the nested try-catch-finally at that stage. The
15753      last element contains `throws' clause exceptions, if any. */
15754   if (IS_UNCHECKED_EXCEPTION_P (exception))
15755     return 1;
15756   while (list)
15757     {
15758       tree caught;
15759       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15760         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15761           return 1;
15762       list = TREE_CHAIN (list);
15763     }
15764   return 0;
15765 }
15766
15767 static void
15768 purge_unchecked_exceptions (tree mdecl)
15769 {
15770   tree throws = DECL_FUNCTION_THROWS (mdecl);
15771   tree new = NULL_TREE;
15772
15773   while (throws)
15774     {
15775       tree next = TREE_CHAIN (throws);
15776       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15777         {
15778           TREE_CHAIN (throws) = new;
15779           new = throws;
15780         }
15781       throws = next;
15782     }
15783   /* List is inverted here, but it doesn't matter */
15784   DECL_FUNCTION_THROWS (mdecl) = new;
15785 }
15786
15787 /* This function goes over all of CLASS_TYPE ctors and checks whether
15788    each of them features at least one unchecked exception in its
15789    `throws' clause. If it's the case, it returns `true', `false'
15790    otherwise.  */
15791
15792 static bool
15793 ctors_unchecked_throws_clause_p (tree class_type)
15794 {
15795   tree current;
15796
15797   for (current = TYPE_METHODS (class_type); current;
15798        current = TREE_CHAIN (current))
15799     {
15800       bool ctu = false; /* Ctor Throws Unchecked */
15801       if (DECL_CONSTRUCTOR_P (current))
15802         {
15803           tree throws;
15804           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15805                throws = TREE_CHAIN (throws))
15806             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15807               ctu = true;
15808         }
15809       /* We return false as we found one ctor that is unfit. */
15810       if (!ctu && DECL_CONSTRUCTOR_P (current))
15811         return false;
15812     }
15813   /* All ctors feature at least one unchecked exception in their
15814      `throws' clause. */
15815   return true;
15816 }
15817
15818 /* 15.24 Conditional Operator ?: */
15819
15820 static tree
15821 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15822 {
15823   tree cond = TREE_OPERAND (node, 0);
15824   tree op1 = TREE_OPERAND (node, 1);
15825   tree op2 = TREE_OPERAND (node, 2);
15826   tree resulting_type = NULL_TREE;
15827   tree t1, t2, patched;
15828   int error_found = 0;
15829
15830   /* Operands of ?: might be StringBuffers crafted as a result of a
15831      string concatenation. Obtain a descent operand here.  */
15832   if ((patched = patch_string (op1)))
15833     TREE_OPERAND (node, 1) = op1 = patched;
15834   if ((patched = patch_string (op2)))
15835     TREE_OPERAND (node, 2) = op2 = patched;
15836
15837   t1 = TREE_TYPE (op1);
15838   t2 = TREE_TYPE (op2);
15839
15840   /* The first expression must be a boolean */
15841   if (TREE_TYPE (cond) != boolean_type_node)
15842     {
15843       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15844       parse_error_context (wfl_operator,
15845                "Incompatible type for `?:'. Can't convert `%s' to `boolean'",
15846                            lang_printable_name (TREE_TYPE (cond), 0));
15847       error_found = 1;
15848     }
15849
15850   /* Second and third can be numeric, boolean (i.e. primitive),
15851      references or null. Anything else results in an error */
15852   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15853         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15854             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15855         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15856     error_found = 1;
15857
15858   /* Determine the type of the conditional expression. Same types are
15859      easy to deal with */
15860   else if (t1 == t2)
15861     resulting_type = t1;
15862
15863   /* There are different rules for numeric types */
15864   else if (JNUMERIC_TYPE_P (t1))
15865     {
15866       /* if byte/short found, the resulting type is short */
15867       if ((t1 == byte_type_node && t2 == short_type_node)
15868           || (t1 == short_type_node && t2 == byte_type_node))
15869         resulting_type = short_type_node;
15870
15871       /* If t1 is a constant int and t2 is of type byte, short or char
15872          and t1's value fits in t2, then the resulting type is t2 */
15873       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
15874           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
15875         resulting_type = t2;
15876
15877       /* If t2 is a constant int and t1 is of type byte, short or char
15878          and t2's value fits in t1, then the resulting type is t1 */
15879       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
15880           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
15881         resulting_type = t1;
15882
15883       /* Otherwise, binary numeric promotion is applied and the
15884          resulting type is the promoted type of operand 1 and 2 */
15885       else
15886         resulting_type = binary_numeric_promotion (t1, t2,
15887                                                    &TREE_OPERAND (node, 1),
15888                                                    &TREE_OPERAND (node, 2));
15889     }
15890
15891   /* Cases of a reference and a null type */
15892   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
15893     resulting_type = t1;
15894
15895   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
15896     resulting_type = t2;
15897
15898   /* Last case: different reference types. If a type can be converted
15899      into the other one by assignment conversion, the latter
15900      determines the type of the expression */
15901   else if ((resulting_type = try_reference_assignconv (t1, op2)))
15902     resulting_type = promote_type (t1);
15903
15904   else if ((resulting_type = try_reference_assignconv (t2, op1)))
15905     resulting_type = promote_type (t2);
15906
15907   /* If we don't have any resulting type, we're in trouble */
15908   if (!resulting_type)
15909     {
15910       char *t = xstrdup (lang_printable_name (t1, 0));
15911       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15912       parse_error_context (wfl_operator,
15913                  "Incompatible type for `?:'. Can't convert `%s' to `%s'",
15914                            t, lang_printable_name (t2, 0));
15915       free (t);
15916       error_found = 1;
15917     }
15918
15919   if (error_found)
15920     {
15921       TREE_TYPE (node) = error_mark_node;
15922       return error_mark_node;
15923     }
15924
15925   TREE_TYPE (node) = resulting_type;
15926   TREE_SET_CODE (node, COND_EXPR);
15927   CAN_COMPLETE_NORMALLY (node) = 1;
15928   return node;
15929 }
15930
15931 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
15932
15933 static tree
15934 maybe_build_class_init_for_field (tree decl, tree expr)
15935 {
15936   tree clas = DECL_CONTEXT (decl);
15937   if (flag_emit_class_files || flag_emit_xref)
15938     return expr;
15939
15940   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
15941       && FIELD_FINAL (decl))
15942     {
15943       tree init = DECL_INITIAL (decl);
15944       if (init != NULL_TREE)
15945         init = fold_constant_for_init (init, decl);
15946       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
15947         return expr;
15948     }
15949
15950   return build_class_init (clas, expr);
15951 }
15952
15953 /* Try to constant fold NODE.
15954    If NODE is not a constant expression, return NULL_EXPR.
15955    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
15956
15957 static tree
15958 fold_constant_for_init (tree node, tree context)
15959 {
15960   tree op0, op1, val;
15961   enum tree_code code = TREE_CODE (node);
15962
15963   switch (code)
15964     {
15965     case INTEGER_CST:
15966       if (node == null_pointer_node)
15967         return NULL_TREE;
15968     case STRING_CST:
15969     case REAL_CST:
15970       return node;
15971
15972     case PLUS_EXPR:
15973     case MINUS_EXPR:
15974     case MULT_EXPR:
15975     case TRUNC_MOD_EXPR:
15976     case RDIV_EXPR:
15977     case LSHIFT_EXPR:
15978     case RSHIFT_EXPR:
15979     case URSHIFT_EXPR:
15980     case BIT_AND_EXPR:
15981     case BIT_XOR_EXPR:
15982     case BIT_IOR_EXPR:
15983     case TRUTH_ANDIF_EXPR:
15984     case TRUTH_ORIF_EXPR:
15985     case EQ_EXPR:
15986     case NE_EXPR:
15987     case GT_EXPR:
15988     case GE_EXPR:
15989     case LT_EXPR:
15990     case LE_EXPR:
15991       op0 = TREE_OPERAND (node, 0);
15992       op1 = TREE_OPERAND (node, 1);
15993       val = fold_constant_for_init (op0, context);
15994       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15995         return NULL_TREE;
15996       TREE_OPERAND (node, 0) = val;
15997       val = fold_constant_for_init (op1, context);
15998       if (val == NULL_TREE || ! TREE_CONSTANT (val))
15999         return NULL_TREE;
16000       TREE_OPERAND (node, 1) = val;
16001       return patch_binop (node, op0, op1);
16002
16003     case UNARY_PLUS_EXPR:
16004     case NEGATE_EXPR:
16005     case TRUTH_NOT_EXPR:
16006     case BIT_NOT_EXPR:
16007     case CONVERT_EXPR:
16008       op0 = TREE_OPERAND (node, 0);
16009       val = fold_constant_for_init (op0, context);
16010       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16011         return NULL_TREE;
16012       TREE_OPERAND (node, 0) = val;
16013       val = patch_unaryop (node, op0);
16014       if (! TREE_CONSTANT (val))
16015         return NULL_TREE;
16016       return val;
16017
16018       break;
16019
16020     case COND_EXPR:
16021       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
16022       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16023         return NULL_TREE;
16024       TREE_OPERAND (node, 0) = val;
16025       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
16026       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16027         return NULL_TREE;
16028       TREE_OPERAND (node, 1) = val;
16029       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
16030       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16031         return NULL_TREE;
16032       TREE_OPERAND (node, 2) = val;
16033       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
16034         : TREE_OPERAND (node, 2);
16035
16036     case VAR_DECL:
16037     case FIELD_DECL:
16038       if (! FIELD_FINAL (node)
16039           || DECL_INITIAL (node) == NULL_TREE)
16040         return NULL_TREE;
16041       val = DECL_INITIAL (node);
16042       /* Guard against infinite recursion. */
16043       DECL_INITIAL (node) = NULL_TREE;
16044       val = fold_constant_for_init (val, node);
16045       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
16046         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
16047       DECL_INITIAL (node) = val;
16048       return val;
16049
16050     case EXPR_WITH_FILE_LOCATION:
16051       /* Compare java_complete_tree and resolve_expression_name. */
16052       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
16053           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
16054         {
16055           tree name = EXPR_WFL_NODE (node);
16056           tree decl;
16057           if (PRIMARY_P (node))
16058             return NULL_TREE;
16059           else if (! QUALIFIED_P (name))
16060             {
16061               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
16062               if (decl == NULL_TREE
16063                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16064                 return NULL_TREE;
16065               return fold_constant_for_init (decl, decl);
16066             }
16067           else
16068             {
16069               /* Install the proper context for the field resolution.
16070                  The prior context is restored once the name is
16071                  properly qualified. */
16072               tree saved_current_class = current_class;
16073               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
16074               current_class = DECL_CONTEXT (context);
16075               qualify_ambiguous_name (node);
16076               current_class = saved_current_class;
16077               if (resolve_field_access (node, &decl, NULL)
16078                   && decl != NULL_TREE)
16079                 return fold_constant_for_init (decl, decl);
16080               return NULL_TREE;
16081             }
16082         }
16083       else
16084         {
16085           op0 = TREE_OPERAND (node, 0);
16086           val = fold_constant_for_init (op0, context);
16087           if (val == NULL_TREE || ! TREE_CONSTANT (val))
16088             return NULL_TREE;
16089           TREE_OPERAND (node, 0) = val;
16090           return val;
16091         }
16092
16093 #ifdef USE_COMPONENT_REF
16094     case IDENTIFIER:
16095     case COMPONENT_REF:
16096       ?;
16097 #endif
16098
16099     default:
16100       return NULL_TREE;
16101     }
16102 }
16103
16104 #ifdef USE_COMPONENT_REF
16105 /* Context is 'T' for TypeName, 'P' for PackageName,
16106    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16107
16108 tree
16109 resolve_simple_name (tree name, int context)
16110 {
16111 }
16112
16113 tree
16114 resolve_qualified_name (tree name, int context)
16115 {
16116 }
16117 #endif
16118
16119 void
16120 init_src_parse (void)
16121 {
16122   /* Sanity check; we've been bit by this before.  */
16123   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16124     abort ();
16125 }
16126
16127 \f
16128
16129 /* This section deals with the functions that are called when tables
16130    recording class initialization information are traversed.  */
16131
16132 /* Attach to PTR (a block) the declaration found in ENTRY. */
16133
16134 static int
16135 attach_init_test_initialization_flags (void **entry, void *ptr)
16136 {
16137   tree block = (tree)ptr;
16138   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
16139
16140   if (block != error_mark_node)
16141     {
16142       TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
16143       BLOCK_EXPR_DECLS (block) = ite->value;
16144     }
16145   return true;
16146 }
16147
16148 /* This function is called for each class that is known definitely
16149    initialized when a given static method was called. This function
16150    augments a compound expression (INFO) storing all assignment to
16151    initialized static class flags if a flag already existed, otherwise
16152    a new one is created.  */
16153
16154 static int
16155 emit_test_initialization (void **entry_p, void *info)
16156 {
16157   tree l = (tree) info;
16158   tree decl, init;
16159   tree key = (tree) *entry_p;
16160   tree *ite;
16161   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16162
16163   /* If we haven't found a flag and we're dealing with self registered
16164      with current_function_decl, then don't do anything. Self is
16165      always added as definitely initialized but this information is
16166      valid only if used outside the current function. */
16167   if (current_function_decl == TREE_PURPOSE (l)
16168       && java_treetreehash_find (cf_ht, key) == NULL)
16169     return true;
16170
16171   ite = java_treetreehash_new (cf_ht, key);
16172
16173   /* If we don't have a variable, create one and install it. */
16174   if (*ite == NULL)
16175     {
16176       tree block;
16177
16178       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16179       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16180       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16181       DECL_CONTEXT (decl) = current_function_decl;
16182       DECL_INITIAL (decl) = boolean_true_node;
16183       /* Don't emit any symbolic debugging info for this decl.  */
16184       DECL_IGNORED_P (decl) = 1;
16185
16186       /* The trick is to find the right context for it. */
16187       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16188       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16189       BLOCK_EXPR_DECLS (block) = decl;
16190       *ite = decl;
16191     }
16192   else
16193     decl = *ite;
16194
16195   /* Now simply augment the compound that holds all the assignments
16196      pertaining to this method invocation. */
16197   init = build (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16198   TREE_SIDE_EFFECTS (init) = 1;
16199   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16200   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16201
16202   return true;
16203 }
16204
16205 #include "gt-java-parse.h"
16206 #include "gtype-java.h"