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, 2005
   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 "pretty-print.h"
  61 #include "diagnostic.h"
  62 #include "flags.h"
  63 #include "java-tree.h"
  64 #include "jcf.h"
  65 #include "lex.h"
  66 #include "parse.h"
  67 #include "zipfile.h"
  68 #include "convert.h"
  69 #include "buffer.h"
  70 #include "function.h"
  71 #include "except.h"
  72 #include "ggc.h"
  73 #include "debug.h"
  74 #include "tree-inline.h"
  75 #include "cgraph.h"
  76 #include "target.h"
  77
  78 /* Local function prototypes */
  79 static char *java_accstring_lookup (int);
  80 static const char *accessibility_string (int);
  81 static void  classitf_redefinition_error (const char *,tree, tree, tree);
  82 static void  variable_redefinition_error (tree, tree, tree, int);
  83 static tree  create_class (int, tree, tree, tree);
  84 static tree  create_interface (int, tree, tree);
  85 static void  end_class_declaration (int);
  86 static tree  find_field (tree, tree);
  87 static tree lookup_field_wrapper (tree, tree);
  88 static int   duplicate_declaration_error_p (tree, tree, tree);
  89 static void  register_fields (int, tree, tree);
  90 static tree parser_qualified_classname (tree);
  91 static int  parser_check_super (tree, tree, tree);
  92 static int  parser_check_super_interface (tree, tree, tree);
  93 static void check_modifiers_consistency (int);
  94 static tree lookup_cl (tree);
  95 static tree lookup_java_method2 (tree, tree, int);
  96 static tree method_header (int, tree, tree, tree);
  97 static void fix_method_argument_names (tree ,tree);
  98 static tree method_declarator (tree, tree);
  99 static void parse_warning_context (tree cl, const char *msgid, ...);
 100 #ifdef USE_MAPPED_LOCATION
 101 static void issue_warning_error_from_context
 102   (source_location, const char *msgid, va_list *);
 103 #else
 104 static void issue_warning_error_from_context
 105   (tree, const char *msgid, va_list *);
 106 #endif
 107 static void parse_ctor_invocation_error (void);
 108 static tree parse_jdk1_1_error (const char *);
 109 static void complete_class_report_errors (jdep *);
 110 static int process_imports (void);
 111 static void read_import_dir (tree);
 112 static int find_in_imports_on_demand (tree, tree);
 113 static void find_in_imports (tree, tree);
 114 static void check_inner_class_access (tree, tree, tree);
 115 static int check_pkg_class_access (tree, tree, bool, tree);
 116 static void register_package (tree);
 117 static tree resolve_package (tree, tree *, tree *);
 118 static tree resolve_class (tree, tree, tree, tree);
 119 static void declare_local_variables (int, tree, tree);
 120 static void dump_java_tree (enum tree_dump_index, tree);
 121 static void source_start_java_method (tree);
 122 static void source_end_java_method (void);
 123 static tree find_name_in_single_imports (tree);
 124 static void check_abstract_method_header (tree);
 125 static tree lookup_java_interface_method2 (tree, tree);
 126 static tree resolve_expression_name (tree, tree *);
 127 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
 128 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
 129 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
 130 static tree resolve_and_layout (tree, tree);
 131 static tree qualify_and_find (tree, tree, tree);
 132 static tree resolve_no_layout (tree, tree);
 133 static int invocation_mode (tree, int);
 134 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
 135 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
 136 static tree find_most_specific_methods_list (tree);
 137 static int argument_types_convertible (tree, tree);
 138 static tree patch_invoke (tree, tree, tree);
 139 static int maybe_use_access_method (int, tree *, tree *);
 140 static tree lookup_method_invoke (int, tree, tree, tree, tree);
 141 static tree register_incomplete_type (int, tree, tree, tree);
 142 static tree check_inner_circular_reference (tree, tree);
 143 static tree check_circular_reference (tree);
 144 static tree obtain_incomplete_type (tree);
 145 static tree java_complete_lhs (tree);
 146 static tree java_complete_tree (tree);
 147 static tree maybe_generate_pre_expand_clinit (tree);
 148 static int analyze_clinit_body (tree, tree);
 149 static int maybe_yank_clinit (tree);
 150 static void start_complete_expand_method (tree);
 151 static void java_complete_expand_method (tree);
 152 static void java_expand_method_bodies (tree);
 153 static int  unresolved_type_p (tree, tree *);
 154 static void create_jdep_list (struct parser_ctxt *);
 155 static tree build_expr_block (tree, tree);
 156 static tree enter_block (void);
 157 static tree exit_block (void);
 158 static tree lookup_name_in_blocks (tree);
 159 static void maybe_absorb_scoping_blocks (void);
 160 static tree build_method_invocation (tree, tree);
 161 static tree build_new_invocation (tree, tree);
 162 static tree build_assignment (int, int, tree, tree);
 163 static tree build_binop (enum tree_code, int, tree, tree);
 164 static tree patch_assignment (tree, tree);
 165 static tree patch_binop (tree, tree, tree);
 166 static tree build_unaryop (int, int, tree);
 167 static tree build_incdec (int, int, tree, int);
 168 static tree patch_unaryop (tree, tree);
 169 static tree build_cast (int, tree, tree);
 170 static tree build_null_of_type (tree);
 171 static tree patch_cast (tree, tree);
 172 static int valid_ref_assignconv_cast_p (tree, tree, int);
 173 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
 174 static int valid_cast_to_p (tree, tree);
 175 static int valid_method_invocation_conversion_p (tree, tree);
 176 static tree try_builtin_assignconv (tree, tree, tree);
 177 static tree try_reference_assignconv (tree, tree);
 178 static tree build_unresolved_array_type (tree);
 179 static int build_type_name_from_array_name (tree, tree *);
 180 static tree build_array_from_name (tree, tree, tree, tree *);
 181 static tree build_array_ref (int, tree, tree);
 182 static tree patch_array_ref (tree);
 183 #ifdef USE_MAPPED_LOCATION
 184 static tree make_qualified_name (tree, tree, source_location);
 185 #else
 186 static tree make_qualified_name (tree, tree, int);
 187 #endif
 188 static tree merge_qualified_name (tree, tree);
 189 static tree make_qualified_primary (tree, tree, int);
 190 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
 191 static void qualify_ambiguous_name (tree);
 192 static tree resolve_field_access (tree, tree *, tree *);
 193 static tree build_newarray_node (tree, tree, int);
 194 static tree patch_newarray (tree);
 195 static tree resolve_type_during_patch (tree);
 196 static tree build_this (int);
 197 static tree build_wfl_wrap (tree, int);
 198 static tree build_return (int, tree);
 199 static tree patch_return (tree);
 200 static tree maybe_access_field (tree, tree, tree);
 201 static int complete_function_arguments (tree);
 202 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
 203 static int not_accessible_p (tree, tree, tree, int);
 204 static void check_deprecation (tree, tree);
 205 static int class_in_current_package (tree);
 206 static tree build_if_else_statement (int, tree, tree, tree);
 207 static tree patch_if_else_statement (tree);
 208 static tree add_stmt_to_block (tree, tree, tree);
 209 static tree patch_exit_expr (tree);
 210 static tree build_labeled_block (int, tree);
 211 static tree finish_labeled_statement (tree, tree);
 212 static tree build_bc_statement (int, int, tree);
 213 static tree patch_bc_statement (tree);
 214 static tree patch_loop_statement (tree);
 215 static tree build_new_loop (tree);
 216 static tree build_loop_body (int, tree, int);
 217 static tree finish_loop_body (int, tree, tree, int);
 218 static tree build_debugable_stmt (int, tree);
 219 static tree finish_for_loop (int, tree, tree, tree);
 220 static tree patch_switch_statement (tree);
 221 static tree string_constant_concatenation (tree, tree);
 222 static tree build_string_concatenation (tree, tree);
 223 static tree patch_string_cst (tree);
 224 static tree patch_string (tree);
 225 static tree encapsulate_with_try_catch (int, tree, tree, tree);
 226 #ifdef USE_MAPPED_LOCATION
 227 static tree build_assertion (source_location, tree, tree);
 228 #else
 229 static tree build_assertion (int, tree, tree);
 230 #endif
 231 static tree build_try_statement (int, tree, tree);
 232 static tree build_try_finally_statement (int, tree, tree);
 233 static tree patch_try_statement (tree);
 234 static tree patch_synchronized_statement (tree, tree);
 235 static tree patch_throw_statement (tree, tree);
 236 #ifdef USE_MAPPED_LOCATION
 237 static void check_thrown_exceptions (source_location, tree, tree);
 238 #else
 239 static void check_thrown_exceptions (int, tree, tree);
 240 #endif
 241 static int check_thrown_exceptions_do (tree);
 242 static void purge_unchecked_exceptions (tree);
 243 static bool ctors_unchecked_throws_clause_p (tree);
 244 static void check_concrete_throws_clauses (tree, tree, tree, tree);
 245 static void check_throws_clauses (tree, tree, tree);
 246 static void finish_method_declaration (tree);
 247 static tree build_super_invocation (tree);
 248 static int verify_constructor_circularity (tree, tree);
 249 static char *constructor_circularity_msg (tree, tree);
 250 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
 251 static const char *get_printable_method_name (tree);
 252 static tree patch_conditional_expr (tree, tree, tree);
 253 static tree generate_finit (tree);
 254 static tree generate_instinit (tree);
 255 static tree build_instinit_invocation (tree);
 256 static void fix_constructors (tree);
 257 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
 258 static tree craft_constructor (tree, tree);
 259 static int verify_constructor_super (tree);
 260 static tree create_artificial_method (tree, int, tree, tree, tree);
 261 static void start_artificial_method_body (tree);
 262 static void end_artificial_method_body (tree);
 263 static int check_method_redefinition (tree, tree);
 264 static int check_method_types_complete (tree);
 265 static bool hack_is_accessible_p (tree, tree);
 266 static void java_check_regular_methods (tree);
 267 static void check_interface_throws_clauses (tree, tree);
 268 static void java_check_abstract_methods (tree);
 269 static void unreachable_stmt_error (tree);
 270 static int not_accessible_field_error (tree, tree);
 271 static tree find_expr_with_wfl (tree);
 272 static void missing_return_error (tree);
 273 static tree build_new_array_init (int, tree);
 274 static tree patch_new_array_init (tree, tree);
 275 static tree maybe_build_array_element_wfl (tree);
 276 static int array_constructor_check_entry (tree, tree);
 277 static const char *purify_type_name (const char *);
 278 static tree fold_constant_for_init (tree, tree);
 279 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
 280 static void static_ref_err (tree, tree, tree);
 281 static void parser_add_interface (tree, tree, tree);
 282 static void add_superinterfaces (tree, tree);
 283 static tree jdep_resolve_class (jdep *);
 284 static int note_possible_classname (const char *, int);
 285 static void java_complete_expand_classes (void);
 286 static void java_complete_expand_class (tree);
 287 static void java_complete_expand_methods (tree);
 288 static tree cut_identifier_in_qualified (tree);
 289 static tree java_stabilize_reference (tree);
 290 static tree do_unary_numeric_promotion (tree);
 291 static char * operator_string (tree);
 292 static tree do_merge_string_cste (tree, const char *, int, int);
 293 static tree merge_string_cste (tree, tree, int);
 294 static tree java_refold (tree);
 295 static int java_decl_equiv (tree, tree);
 296 static int binop_compound_p (enum tree_code);
 297 static tree search_loop (tree);
 298 static int labeled_block_contains_loop_p (tree, tree);
 299 static int check_abstract_method_definitions (int, tree, tree);
 300 static void java_check_abstract_method_definitions (tree);
 301 static void java_debug_context_do (int);
 302 static void java_parser_context_push_initialized_field (void);
 303 static void java_parser_context_pop_initialized_field (void);
 304 static tree reorder_static_initialized (tree);
 305 static void java_parser_context_suspend (void);
 306 static void java_parser_context_resume (void);
 307 static int pop_current_osb (struct parser_ctxt *);
 308
 309 /* JDK 1.1 work. FIXME */
 310
 311 static tree maybe_make_nested_class_name (tree);
 312 static int make_nested_class_name (tree);
 313 static void link_nested_class_to_enclosing (void);
 314 static tree resolve_inner_class (htab_t, tree, tree *, tree *, tree);
 315 static tree find_as_inner_class (tree, tree, tree);
 316 static tree find_as_inner_class_do (tree, tree);
 317 static int check_inner_class_redefinition (tree, tree);
 318
 319 static tree build_thisn_assign (void);
 320 static tree build_current_thisn (tree);
 321 static tree build_access_to_thisn (tree, tree, int);
 322 static tree maybe_build_thisn_access_method (tree);
 323
 324 static tree build_outer_field_access (tree, tree);
 325 static tree build_outer_field_access_methods (tree);
 326 static tree build_outer_field_access_expr (int, tree, tree,
 327                                                   tree, tree);
 328 static tree build_outer_method_access_method (tree);
 329 static tree build_new_access_id (void);
 330 static tree build_outer_field_access_method (tree, tree, tree,
 331                                                     tree, tree);
 332
 333 static int outer_field_access_p (tree, tree);
 334 static int outer_field_expanded_access_p (tree, tree *,
 335                                                  tree *, tree *);
 336 static tree outer_field_access_fix (tree, tree, tree);
 337 static tree build_incomplete_class_ref (int, tree);
 338 static tree patch_incomplete_class_ref (tree);
 339 static tree create_anonymous_class (tree);
 340 static void patch_anonymous_class (tree, tree, tree);
 341 static void add_inner_class_fields (tree, tree);
 342
 343 static tree build_dot_class_method (tree);
 344 static tree build_dot_class_method_invocation (tree, tree);
 345 static void create_new_parser_context (int);
 346 static tree maybe_build_class_init_for_field (tree, tree);
 347
 348 static int emit_test_initialization (void **, void *);
 349
 350 static char *string_convert_int_cst (tree);
 351
 352 /* Number of error found so far. */
 353 int java_error_count;
 354 /* Number of warning found so far. */
 355 int java_warning_count;
 356 /* Cyclic inheritance report, as it can be set by layout_class */
 357 const char *cyclic_inheritance_report;
 358
 359 /* The current parser context */
 360 struct parser_ctxt *ctxp;
 361
 362 /* List of things that were analyzed for which code will be generated */
 363 struct parser_ctxt *ctxp_for_generation = NULL;
 364
 365 /* binop_lookup maps token to tree_code. It is used where binary
 366    operations are involved and required by the parser. RDIV_EXPR
 367    covers both integral/floating point division. The code is changed
 368    once the type of both operator is worked out.  */
 369
 370 static const enum tree_code binop_lookup[19] =
 371   {
 372     PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
 373     LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
 374     BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
 375     TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
 376     EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
 377    };
 378 #define BINOP_LOOKUP(VALUE)                                             \
 379   binop_lookup [((VALUE) - PLUS_TK) % ARRAY_SIZE (binop_lookup)]
 380
 381 /* This is the end index for binary operators that can also be used
 382    in compound assignments. */
 383 #define BINOP_COMPOUND_CANDIDATES 11
 384
 385 /* The "$L" identifier we use to create labels.  */
 386 static GTY(()) tree label_id;
 387
 388 /* The "StringBuffer" identifier used for the String `+' operator. */
 389 static GTY(()) tree wfl_string_buffer;
 390
 391 /* The "append" identifier used for String `+' operator.  */
 392 static GTY(()) tree wfl_append;
 393
 394 /* The "toString" identifier used for String `+' operator. */
 395 static GTY(()) tree wfl_to_string;
 396
 397 /* The "java.lang" import qualified name.  */
 398 static GTY(()) tree java_lang_id;
 399
 400 /* The generated `inst$' identifier used for generated enclosing
 401    instance/field access functions.  */
 402 static GTY(()) tree inst_id;
 403
 404 /* Context and flag for static blocks */
 405 static GTY(()) tree current_static_block;
 406
 407 /* The generated `write_parm_value$' identifier.  */
 408 static GTY(()) tree wpv_id;
 409
 410 /* The list of all packages we've seen so far */
 411 static GTY(()) tree package_list;
 412
 413 /* Hold THIS for the scope of the current method decl.  */
 414 static GTY(()) tree current_this;
 415
 416 /* Hold a list of catch clauses list. The first element of this list is
 417    the list of the catch clauses of the currently analyzed try block. */
 418 static GTY(()) tree currently_caught_type_list;
 419
 420 /* This holds a linked list of all the case labels for the current
 421    switch statement.  It is only used when checking to see if there
 422    are duplicate labels.  FIXME: probably this should just be attached
 423    to the switch itself; then it could be referenced via
 424    `ctxp->current_loop'.  */
 425 static GTY(()) tree case_label_list;
 426
 427 /* Anonymous class counter. Will be reset to 1 every time a non
 428    anonymous class gets created. */
 429 static int anonymous_class_counter = 1;
 430
 431 static GTY(()) tree src_parse_roots[1];
 432
 433 /* All classes seen from source code */
 434 #define gclass_list src_parse_roots[0]
 435
 436 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
 437    line and point it out.  */
 438 /* Should point out the one that don't fit. ASCII/unicode, going
 439    backward. FIXME */
 440
 441 #define check_modifiers(__message, __value, __mask) do {        \
 442   if ((__value) & ~(__mask))                                    \
 443     {                                                           \
 444       size_t i, remainder = (__value) & ~(__mask);              \
 445       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)     \
 446         if ((1 << i) & remainder)                               \
 447           parse_error_context (ctxp->modifier_ctx [i], (__message), \
 448                                java_accstring_lookup (1 << i)); \
 449     }                                                           \
 450 } while (0)
 451
 452 %}
 453
 454 %union {
 455   tree node;
 456   int sub_token;
 457   struct {
 458     int token;
 459 #ifdef USE_MAPPED_LOCATION
 460     source_location location;
 461 #else
 462     int location;
 463 #endif
 464   } operator;
 465   int value;
 466 }
 467
 468 %{
 469 #ifdef USE_MAPPED_LOCATION
 470 #define SET_EXPR_LOCATION_FROM_TOKEN(EXPR, TOKEN) \
 471   SET_EXPR_LOCATION(EXPR, (TOKEN).location)
 472 #else
 473 #define SET_EXPR_LOCATION_FROM_TOKEN(EXPR, TOKEN) \
 474   (EXPR_WFL_LINECOL (EXPR) = (TOKEN).location)
 475 #endif
 476
 477 #include "lex.c"
 478 %}
 479
 480 %pure_parser
 481
 482 /* Things defined here have to match the order of what's in the
 483    binop_lookup table.  */
 484
 485 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
 486 %token   LS_TK           SRS_TK          ZRS_TK
 487 %token   AND_TK          XOR_TK          OR_TK
 488 %token   BOOL_AND_TK BOOL_OR_TK
 489 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
 490
 491 /* This maps to the same binop_lookup entry than the token above */
 492
 493 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
 494 %token   REM_ASSIGN_TK
 495 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 496 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
 497
 498
 499 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
 500
 501 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
 502 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
 503 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
 504 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
 505 %token   MODIFIER_TK
 506
 507 /* Keep those two in order, too */
 508 %token   DECR_TK INCR_TK
 509
 510 /* From now one, things can be in any order */
 511
 512 %token   DEFAULT_TK      IF_TK              THROW_TK
 513 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
 514 %token   THROWS_TK       BREAK_TK           IMPORT_TK
 515 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
 516 %token   VOID_TK         CATCH_TK           INTERFACE_TK
 517 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
 518 %token   SUPER_TK        WHILE_TK           CLASS_TK
 519 %token   SWITCH_TK       CONST_TK           TRY_TK
 520 %token   FOR_TK          NEW_TK             CONTINUE_TK
 521 %token   GOTO_TK         PACKAGE_TK         THIS_TK
 522 %token   ASSERT_TK
 523
 524 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
 525 %token   CHAR_TK         INTEGRAL_TK
 526
 527 %token   FLOAT_TK        DOUBLE_TK          FP_TK
 528
 529 %token   ID_TK
 530
 531 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
 532
 533 %token   ASSIGN_ANY_TK   ASSIGN_TK
 534 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
 535
 536 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
 537 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
 538
 539 %type    <value>        modifiers MODIFIER_TK final synchronized
 540
 541 %type    <node>         super ID_TK identifier
 542 %type    <node>         name simple_name qualified_name
 543 %type    <node>         type_declaration compilation_unit
 544                         field_declaration method_declaration extends_interfaces
 545                         interfaces interface_type_list
 546                         import_declarations package_declaration
 547                         type_declarations interface_body
 548                         interface_member_declaration constant_declaration
 549                         interface_member_declarations interface_type
 550                         abstract_method_declaration
 551 %type    <node>         class_body_declaration class_member_declaration
 552                         static_initializer constructor_declaration block
 553 %type    <node>         class_body_declarations constructor_header
 554 %type    <node>         class_or_interface_type class_type class_type_list
 555                         constructor_declarator explicit_constructor_invocation
 556 %type    <node>         dim_expr dim_exprs this_or_super throws
 557
 558 %type    <node>         variable_declarator_id variable_declarator
 559                         variable_declarators variable_initializer
 560                         variable_initializers constructor_body
 561                         array_initializer
 562
 563 %type    <node>         class_body block_end constructor_block_end
 564 %type    <node>         statement statement_without_trailing_substatement
 565                         labeled_statement if_then_statement label_decl
 566                         if_then_else_statement while_statement for_statement
 567                         statement_nsi labeled_statement_nsi do_statement
 568                         if_then_else_statement_nsi while_statement_nsi
 569                         for_statement_nsi statement_expression_list for_init
 570                         for_update statement_expression expression_statement
 571                         primary_no_new_array expression primary array_type
 572                         array_creation_initialized array_creation_uninitialized
 573                         class_instance_creation_expression field_access
 574                         method_invocation array_access something_dot_new
 575                         argument_list postfix_expression while_expression
 576                         post_increment_expression post_decrement_expression
 577                         unary_expression_not_plus_minus unary_expression
 578                         pre_increment_expression pre_decrement_expression
 579                         cast_expression
 580                         multiplicative_expression additive_expression
 581                         shift_expression relational_expression
 582                         equality_expression and_expression
 583                         exclusive_or_expression inclusive_or_expression
 584                         conditional_and_expression conditional_or_expression
 585                         conditional_expression assignment_expression
 586                         left_hand_side assignment for_header for_begin
 587                         constant_expression do_statement_begin empty_statement
 588                         switch_statement synchronized_statement throw_statement
 589                         try_statement assert_statement
 590                         switch_expression switch_block
 591                         catches catch_clause catch_clause_parameter finally
 592                         anonymous_class_creation trap_overflow_corner_case
 593 %type    <node>         return_statement break_statement continue_statement
 594
 595 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
 596 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
 597 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 598 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
 599 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
 600 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
 601 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
 602 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
 603 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
 604 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
 605 %type    <operator>     THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
 606 %type    <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
 607 %type    <operator>     NEW_TK ASSERT_TK
 608
 609 %type    <node>         method_body
 610
 611 %type    <node>         literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
 612                         STRING_LIT_TK NULL_TK VOID_TK
 613
 614 %type    <node>         IF_TK WHILE_TK FOR_TK
 615
 616 %type    <node>         formal_parameter_list formal_parameter
 617                         method_declarator method_header
 618
 619 %type    <node>         primitive_type reference_type type
 620                         BOOLEAN_TK INTEGRAL_TK FP_TK
 621
 622 /* Added or modified JDK 1.1 rule types  */
 623 %type    <node>         type_literals
 624
 625 %%
 626 /* 19.2 Production from 2.3: The Syntactic Grammar  */
 627 goal:  compilation_unit
 628                 {}
 629 ;
 630
 631 /* 19.3 Productions from 3: Lexical structure  */
 632 literal:
 633         INT_LIT_TK
 634 |       FP_LIT_TK
 635 |       BOOL_LIT_TK
 636 |       CHAR_LIT_TK
 637 |       STRING_LIT_TK
 638 |       NULL_TK
 639 ;
 640
 641 /* 19.4 Productions from 4: Types, Values and Variables  */
 642 type:
 643         primitive_type
 644 |       reference_type
 645 ;
 646
 647 primitive_type:
 648         INTEGRAL_TK
 649 |       FP_TK
 650 |       BOOLEAN_TK
 651 ;
 652
 653 reference_type:
 654         class_or_interface_type
 655 |       array_type
 656 ;
 657
 658 class_or_interface_type:
 659         name
 660 ;
 661
 662 class_type:
 663         class_or_interface_type /* Default rule */
 664 ;
 665
 666 interface_type:
 667          class_or_interface_type
 668 ;
 669
 670 array_type:
 671         primitive_type dims
 672                 {
 673                   int osb = pop_current_osb (ctxp);
 674                   tree t = build_java_array_type (($1), -1);
 675                   while (--osb)
 676                     t = build_unresolved_array_type (t);
 677                   $$ = t;
 678                 }
 679 |       name dims
 680                 {
 681                   int osb = pop_current_osb (ctxp);
 682                   tree t = $1;
 683                   while (osb--)
 684                     t = build_unresolved_array_type (t);
 685                   $$ = t;
 686                 }
 687 ;
 688
 689 /* 19.5 Productions from 6: Names  */
 690 name:
 691         simple_name             /* Default rule */
 692 |       qualified_name          /* Default rule */
 693 ;
 694
 695 simple_name:
 696         identifier              /* Default rule */
 697 ;
 698
 699 qualified_name:
 700         name DOT_TK identifier
 701                 { $$ = make_qualified_name ($1, $3, $2.location); }
 702 ;
 703
 704 identifier:
 705         ID_TK
 706 ;
 707
 708 /* 19.6: Production from 7: Packages  */
 709 compilation_unit:
 710                 {$$ = NULL;}
 711 |       package_declaration
 712 |       import_declarations
 713 |       type_declarations
 714 |       package_declaration import_declarations
 715 |       package_declaration type_declarations
 716 |       import_declarations type_declarations
 717 |       package_declaration import_declarations type_declarations
 718 ;
 719
 720 import_declarations:
 721         import_declaration
 722                 {
 723                   $$ = NULL;
 724                 }
 725 |       import_declarations import_declaration
 726                 {
 727                   $$ = NULL;
 728                 }
 729 ;
 730
 731 type_declarations:
 732         type_declaration
 733 |       type_declarations type_declaration
 734 ;
 735
 736 package_declaration:
 737         PACKAGE_TK name SC_TK
 738                 {
 739                   ctxp->package = EXPR_WFL_NODE ($2);
 740                   register_package (ctxp->package);
 741                 }
 742 |       PACKAGE_TK error
 743                 {yyerror ("Missing name"); RECOVER;}
 744 |       PACKAGE_TK name error
 745                 {yyerror ("';' expected"); RECOVER;}
 746 ;
 747
 748 import_declaration:
 749         single_type_import_declaration
 750 |       type_import_on_demand_declaration
 751 ;
 752
 753 single_type_import_declaration:
 754         IMPORT_TK name SC_TK
 755                 {
 756                   tree name = EXPR_WFL_NODE ($2), last_name;
 757                   int   i = IDENTIFIER_LENGTH (name)-1;
 758                   const char *last = &IDENTIFIER_POINTER (name)[i];
 759                   while (last != IDENTIFIER_POINTER (name))
 760                     {
 761                       if (last [0] == '.')
 762                         break;
 763                       last--;
 764                     }
 765                   last_name = get_identifier (++last);
 766                   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
 767                     {
 768                       tree err = find_name_in_single_imports (last_name);
 769                       if (err && err != name)
 770                         parse_error_context
 771                           ($2, "Ambiguous class: %qs and %qs",
 772                            IDENTIFIER_POINTER (name),
 773                            IDENTIFIER_POINTER (err));
 774                       else
 775                         REGISTER_IMPORT ($2, last_name);
 776                     }
 777                   else
 778                     REGISTER_IMPORT ($2, last_name);
 779                 }
 780 |       IMPORT_TK error
 781                 {yyerror ("Missing name"); RECOVER;}
 782 |       IMPORT_TK name error
 783                 {yyerror ("';' expected"); RECOVER;}
 784 ;
 785
 786 type_import_on_demand_declaration:
 787         IMPORT_TK name DOT_TK MULT_TK SC_TK
 788                 {
 789                   tree name = EXPR_WFL_NODE ($2);
 790                   tree it;
 791                   /* Search for duplicates. */
 792                   for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
 793                     if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
 794                       break;
 795                   /* Don't import the same thing more than once, just ignore
 796                      duplicates (7.5.2) */
 797                   if (! it)
 798                     {
 799                       read_import_dir ($2);
 800                       ctxp->import_demand_list =
 801                         chainon (ctxp->import_demand_list,
 802                                  build_tree_list ($2, NULL_TREE));
 803                     }
 804                 }
 805 |       IMPORT_TK name DOT_TK error
 806                 {yyerror ("'*' expected"); RECOVER;}
 807 |       IMPORT_TK name DOT_TK MULT_TK error
 808                 {yyerror ("';' expected"); RECOVER;}
 809 ;
 810
 811 type_declaration:
 812         class_declaration
 813                 { end_class_declaration (0); }
 814 |       interface_declaration
 815                 { end_class_declaration (0); }
 816 |       empty_statement
 817 |       error
 818                 {
 819                   YYERROR_NOW;
 820                   yyerror ("Class or interface declaration expected");
 821                 }
 822 ;
 823
 824 /* 19.7 Shortened from the original:
 825    modifiers: modifier | modifiers modifier
 826    modifier: any of public...  */
 827 modifiers:
 828         MODIFIER_TK
 829                 {
 830                   $$ = (1 << $1);
 831                 }
 832 |       modifiers MODIFIER_TK
 833                 {
 834                   int acc = (1 << $2);
 835                   if ($$ & acc)
 836                     parse_error_context
 837                       (ctxp->modifier_ctx [$2], "Modifier %qs declared twice",
 838                        java_accstring_lookup (acc));
 839                   else
 840                     {
 841                       $$ |= acc;
 842                     }
 843                 }
 844 ;
 845
 846 /* 19.8.1 Production from $8.1: Class Declaration */
 847 class_declaration:
 848         modifiers CLASS_TK identifier super interfaces
 849                 { create_class ($1, $3, $4, $5); }
 850         class_body
 851                 {;}
 852 |       CLASS_TK identifier super interfaces
 853                 { create_class (0, $2, $3, $4); }
 854         class_body
 855                 {;}
 856 |       modifiers CLASS_TK error
 857                 { yyerror ("Missing class name"); RECOVER; }
 858 |       CLASS_TK error
 859                 { yyerror ("Missing class name"); RECOVER; }
 860 |       CLASS_TK identifier error
 861                 {
 862                   if (!ctxp->class_err) yyerror ("'{' expected");
 863                   DRECOVER(class1);
 864                 }
 865 |       modifiers CLASS_TK identifier error
 866                 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
 867 ;
 868
 869 super:
 870                 { $$ = NULL; }
 871 |       EXTENDS_TK class_type
 872                 { $$ = $2; }
 873 |       EXTENDS_TK class_type error
 874                 {yyerror ("'{' expected"); ctxp->class_err=1;}
 875 |       EXTENDS_TK error
 876                 {yyerror ("Missing super class name"); ctxp->class_err=1;}
 877 ;
 878
 879 interfaces:
 880                 { $$ = NULL_TREE; }
 881 |       IMPLEMENTS_TK interface_type_list
 882                 { $$ = $2; }
 883 |       IMPLEMENTS_TK error
 884                 {
 885                   ctxp->class_err=1;
 886                   yyerror ("Missing interface name");
 887                 }
 888 ;
 889
 890 interface_type_list:
 891         interface_type
 892                 {
 893                   ctxp->interface_number = 1;
 894                   $$ = build_tree_list ($1, NULL_TREE);
 895                 }
 896 |       interface_type_list C_TK interface_type
 897                 {
 898                   ctxp->interface_number++;
 899                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
 900                 }
 901 |       interface_type_list C_TK error
 902                 {yyerror ("Missing interface name"); RECOVER;}
 903 ;
 904
 905 class_body:
 906         OCB_TK CCB_TK
 907                 {
 908                   $$ = GET_CPC ();
 909                 }
 910 |       OCB_TK class_body_declarations CCB_TK
 911                 {
 912                   $$ = GET_CPC ();
 913                 }
 914 ;
 915
 916 class_body_declarations:
 917         class_body_declaration
 918 |       class_body_declarations class_body_declaration
 919 ;
 920
 921 class_body_declaration:
 922         class_member_declaration
 923 |       static_initializer
 924 |       constructor_declaration
 925 |       block                   /* Added, JDK1.1, instance initializer */
 926                 {
 927                   if (!IS_EMPTY_STMT ($1))
 928                     {
 929                       TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
 930                       SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
 931                     }
 932                 }
 933 ;
 934
 935 class_member_declaration:
 936         field_declaration
 937 |       method_declaration
 938 |       class_declaration       /* Added, JDK1.1 inner classes */
 939                 { end_class_declaration (1); }
 940 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
 941                 { end_class_declaration (1); }
 942 |       empty_statement
 943 ;
 944
 945 /* 19.8.2 Productions from 8.3: Field Declarations  */
 946 field_declaration:
 947         type variable_declarators SC_TK
 948                 { register_fields (0, $1, $2); }
 949 |       modifiers type variable_declarators SC_TK
 950                 {
 951                   check_modifiers
 952                     ("Illegal modifier %qs for field declaration",
 953                      $1, FIELD_MODIFIERS);
 954                   check_modifiers_consistency ($1);
 955                   register_fields ($1, $2, $3);
 956                 }
 957 ;
 958
 959 variable_declarators:
 960         /* Should we use build_decl_list () instead ? FIXME */
 961         variable_declarator     /* Default rule */
 962 |       variable_declarators C_TK variable_declarator
 963                 { $$ = chainon ($1, $3); }
 964 |       variable_declarators C_TK error
 965                 {yyerror ("Missing term"); RECOVER;}
 966 ;
 967
 968 variable_declarator:
 969         variable_declarator_id
 970                 { $$ = build_tree_list ($1, NULL_TREE); }
 971 |       variable_declarator_id ASSIGN_TK variable_initializer
 972                 {
 973                   if (java_error_count)
 974                     $3 = NULL_TREE;
 975                   $$ = build_tree_list
 976                     ($1, build_assignment ($2.token, $2.location, $1, $3));
 977                 }
 978 |       variable_declarator_id ASSIGN_TK error
 979                 {
 980                   yyerror ("Missing variable initializer");
 981                   $$ = build_tree_list ($1, NULL_TREE);
 982                   RECOVER;
 983                 }
 984 |       variable_declarator_id ASSIGN_TK variable_initializer error
 985                 {
 986                   yyerror ("';' expected");
 987                   $$ = build_tree_list ($1, NULL_TREE);
 988                   RECOVER;
 989                 }
 990 ;
 991
 992 variable_declarator_id:
 993         identifier
 994 |       variable_declarator_id OSB_TK CSB_TK
 995                 { $$ = build_unresolved_array_type ($1); }
 996 |       identifier error
 997                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
 998 |       variable_declarator_id OSB_TK error
 999                 {
1000                   yyerror ("']' expected");
1001                   DRECOVER(vdi);
1002                 }
1003 |       variable_declarator_id CSB_TK error
1004                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
1005 ;
1006
1007 variable_initializer:
1008         expression
1009 |       array_initializer
1010 ;
1011
1012 /* 19.8.3 Productions from 8.4: Method Declarations  */
1013 method_declaration:
1014         method_header
1015                 {
1016                   current_function_decl = $1;
1017                   if (current_function_decl
1018                       && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1019                     source_start_java_method (current_function_decl);
1020                   else
1021                     current_function_decl = NULL_TREE;
1022                 }
1023         method_body
1024                 { finish_method_declaration ($3); }
1025 |       method_header error
1026                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1027 ;
1028
1029 method_header:
1030         type method_declarator throws
1031                 { $$ = method_header (0, $1, $2, $3); }
1032 |       VOID_TK method_declarator throws
1033                 { $$ = method_header (0, void_type_node, $2, $3); }
1034 |       modifiers type method_declarator throws
1035                 { $$ = method_header ($1, $2, $3, $4); }
1036 |       modifiers VOID_TK method_declarator throws
1037                 { $$ = method_header ($1, void_type_node, $3, $4); }
1038 |       type error
1039                 {
1040                   yyerror ("Invalid method declaration, method name required");
1041                   RECOVER;
1042                 }
1043 |       modifiers type error
1044                 {
1045                   yyerror ("Identifier expected");
1046                   RECOVER;
1047                 }
1048 |       VOID_TK error
1049                 {
1050                   yyerror ("Identifier expected");
1051                   RECOVER;
1052                 }
1053 |       modifiers VOID_TK error
1054                 {
1055                   yyerror ("Identifier expected");
1056                   RECOVER;
1057                 }
1058 |       modifiers error
1059                 {
1060                   yyerror ("Invalid method declaration, return type required");
1061                   RECOVER;
1062                 }
1063 ;
1064
1065 method_declarator:
1066         identifier OP_TK CP_TK
1067                 {
1068                   ctxp->formal_parameter_number = 0;
1069                   $$ = method_declarator ($1, NULL_TREE);
1070                 }
1071 |       identifier OP_TK formal_parameter_list CP_TK
1072                 { $$ = method_declarator ($1, $3); }
1073 |       method_declarator OSB_TK CSB_TK
1074                 {
1075                   SET_EXPR_LOCATION_FROM_TOKEN (wfl_operator, $2);
1076                   TREE_PURPOSE ($1) =
1077                     build_unresolved_array_type (TREE_PURPOSE ($1));
1078                   parse_warning_context
1079                     (wfl_operator,
1080                      "Discouraged form of returned type specification");
1081                 }
1082 |       identifier OP_TK error
1083                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1084 |       method_declarator OSB_TK error
1085                 {yyerror ("']' expected"); RECOVER;}
1086 ;
1087
1088 formal_parameter_list:
1089         formal_parameter
1090                 {
1091                   ctxp->formal_parameter_number = 1;
1092                 }
1093 |       formal_parameter_list C_TK formal_parameter
1094                 {
1095                   ctxp->formal_parameter_number += 1;
1096                   $$ = chainon ($1, $3);
1097                 }
1098 |       formal_parameter_list C_TK error
1099                 { yyerror ("Missing formal parameter term"); RECOVER; }
1100 ;
1101
1102 formal_parameter:
1103         type variable_declarator_id
1104                 {
1105                   $$ = build_tree_list ($2, $1);
1106                 }
1107 |       final type variable_declarator_id /* Added, JDK1.1 final parms */
1108                 {
1109                   $$ = build_tree_list ($3, $2);
1110                   ARG_FINAL_P ($$) = 1;
1111                 }
1112 |       type error
1113                 {
1114                   yyerror ("Missing identifier"); RECOVER;
1115                   $$ = NULL_TREE;
1116                 }
1117 |       final type error
1118                 {
1119                   yyerror ("Missing identifier"); RECOVER;
1120                   $$ = NULL_TREE;
1121                 }
1122 ;
1123
1124 final:
1125         modifiers
1126                 {
1127                   check_modifiers ("Illegal modifier %qs. Only %<final%> was expected here",
1128                                    $1, ACC_FINAL);
1129                   if ($1 != ACC_FINAL)
1130                     MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1131                 }
1132 ;
1133
1134 throws:
1135                 { $$ = NULL_TREE; }
1136 |       THROWS_TK class_type_list
1137                 { $$ = $2; }
1138 |       THROWS_TK error
1139                 {yyerror ("Missing class type term"); RECOVER;}
1140 ;
1141
1142 class_type_list:
1143         class_type
1144                 { $$ = build_tree_list ($1, $1); }
1145 |       class_type_list C_TK class_type
1146                 { $$ = tree_cons ($3, $3, $1); }
1147 |       class_type_list C_TK error
1148                 {yyerror ("Missing class type term"); RECOVER;}
1149 ;
1150
1151 method_body:
1152         block
1153 |       SC_TK { $$ = NULL_TREE; }
1154 ;
1155
1156 /* 19.8.4 Productions from 8.5: Static Initializers  */
1157 static_initializer:
1158         static block
1159                 {
1160                   TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1161                   SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1162                   current_static_block = NULL_TREE;
1163                 }
1164 ;
1165
1166 static:                         /* Test lval.sub_token here */
1167         modifiers
1168                 {
1169                   check_modifiers ("Illegal modifier %qs for static initializer", $1, ACC_STATIC);
1170                   /* Can't have a static initializer in an innerclass */
1171                   if ($1 | ACC_STATIC &&
1172                       GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1173                     parse_error_context
1174                       (MODIFIER_WFL (STATIC_TK),
1175                        "Can't define static initializer in class %qs. Static initializer can only be defined in top-level classes",
1176                        IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1177                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1178                 }
1179 ;
1180
1181 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1182 constructor_declaration:
1183         constructor_header
1184                 {
1185                   current_function_decl = $1;
1186                   source_start_java_method (current_function_decl);
1187                 }
1188         constructor_body
1189                 { finish_method_declaration ($3); }
1190 ;
1191
1192 constructor_header:
1193         constructor_declarator throws
1194                 { $$ = method_header (0, NULL_TREE, $1, $2); }
1195 |       modifiers constructor_declarator throws
1196                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1197 ;
1198
1199 constructor_declarator:
1200         simple_name OP_TK CP_TK
1201                 {
1202                   ctxp->formal_parameter_number = 0;
1203                   $$ = method_declarator ($1, NULL_TREE);
1204                 }
1205 |       simple_name OP_TK formal_parameter_list CP_TK
1206                 { $$ = method_declarator ($1, $3); }
1207 ;
1208
1209 constructor_body:
1210         /* Unlike regular method, we always need a complete (empty)
1211            body so we can safely perform all the required code
1212            addition (super invocation and field initialization) */
1213         block_begin constructor_block_end
1214                 {
1215                   BLOCK_EXPR_BODY ($2) = build_java_empty_stmt ();
1216                   $$ = $2;
1217                 }
1218 |       block_begin explicit_constructor_invocation constructor_block_end
1219                 { $$ = $3; }
1220 |       block_begin block_statements constructor_block_end
1221                 { $$ = $3; }
1222 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1223                 { $$ = $4; }
1224 ;
1225
1226 constructor_block_end:
1227         block_end
1228 ;
1229
1230 /* Error recovery for that rule moved down expression_statement: rule.  */
1231 explicit_constructor_invocation:
1232         this_or_super OP_TK CP_TK SC_TK
1233                 {
1234                   $$ = build_method_invocation ($1, NULL_TREE);
1235                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1236                   $$ = java_method_add_stmt (current_function_decl, $$);
1237                 }
1238 |       this_or_super OP_TK argument_list CP_TK SC_TK
1239                 {
1240                   $$ = build_method_invocation ($1, $3);
1241                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1242                   $$ = java_method_add_stmt (current_function_decl, $$);
1243                 }
1244         /* Added, JDK1.1 inner classes. Modified because the rule
1245            'primary' couldn't work.  */
1246 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1247                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1248 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1249                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1250 ;
1251
1252 this_or_super:                  /* Added, simplifies error diagnostics */
1253         THIS_TK
1254                 {
1255                   tree wfl = build_wfl_node (this_identifier_node);
1256                   SET_EXPR_LOCATION_FROM_TOKEN (wfl, $1);
1257                   $$ = wfl;
1258                 }
1259 |       SUPER_TK
1260                 {
1261                   tree wfl = build_wfl_node (super_identifier_node);
1262                   SET_EXPR_LOCATION_FROM_TOKEN (wfl, $1);
1263                   $$ = wfl;
1264                 }
1265 ;
1266
1267 /* 19.9 Productions from 9: Interfaces  */
1268 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1269 interface_declaration:
1270         INTERFACE_TK identifier
1271                 { create_interface (0, $2, NULL_TREE); }
1272         interface_body
1273                 { ; }
1274 |       modifiers INTERFACE_TK identifier
1275                 { create_interface ($1, $3, NULL_TREE); }
1276         interface_body
1277                 { ; }
1278 |       INTERFACE_TK identifier extends_interfaces
1279                 { create_interface (0, $2, $3); }
1280         interface_body
1281                 { ; }
1282 |       modifiers INTERFACE_TK identifier extends_interfaces
1283                 { create_interface ($1, $3, $4); }
1284         interface_body
1285                 { ; }
1286 |       INTERFACE_TK identifier error
1287                 { yyerror ("'{' expected"); RECOVER; }
1288 |       modifiers INTERFACE_TK identifier error
1289                 { yyerror ("'{' expected"); RECOVER; }
1290 ;
1291
1292 extends_interfaces:
1293         EXTENDS_TK interface_type
1294                 {
1295                   ctxp->interface_number = 1;
1296                   $$ = build_tree_list ($2, NULL_TREE);
1297                 }
1298 |       extends_interfaces C_TK interface_type
1299                 {
1300                   ctxp->interface_number++;
1301                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1302                 }
1303 |       EXTENDS_TK error
1304                 {yyerror ("Invalid interface type"); RECOVER;}
1305 |       extends_interfaces C_TK error
1306                 {yyerror ("Missing term"); RECOVER;}
1307 ;
1308
1309 interface_body:
1310         OCB_TK CCB_TK
1311                 { $$ = NULL_TREE; }
1312 |       OCB_TK interface_member_declarations CCB_TK
1313                 { $$ = NULL_TREE; }
1314 ;
1315
1316 interface_member_declarations:
1317         interface_member_declaration
1318 |       interface_member_declarations interface_member_declaration
1319 ;
1320
1321 interface_member_declaration:
1322         constant_declaration
1323 |       abstract_method_declaration
1324 |       class_declaration       /* Added, JDK1.1 inner classes */
1325                 { end_class_declaration (1); }
1326 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
1327                 { end_class_declaration (1); }
1328 ;
1329
1330 constant_declaration:
1331         field_declaration
1332 ;
1333
1334 abstract_method_declaration:
1335         method_header SC_TK
1336                 {
1337                   check_abstract_method_header ($1);
1338                   current_function_decl = NULL_TREE; /* FIXME ? */
1339                 }
1340 |       method_header error
1341                 {yyerror ("';' expected"); RECOVER;}
1342 ;
1343
1344 /* 19.10 Productions from 10: Arrays  */
1345 array_initializer:
1346         OCB_TK CCB_TK
1347                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1348 |       OCB_TK C_TK CCB_TK
1349                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1350 |       OCB_TK variable_initializers CCB_TK
1351                 { $$ = build_new_array_init ($1.location, $2); }
1352 |       OCB_TK variable_initializers C_TK CCB_TK
1353                 { $$ = build_new_array_init ($1.location, $2); }
1354 ;
1355
1356 variable_initializers:
1357         variable_initializer
1358                 {
1359                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1360                                   $1, NULL_TREE);
1361                 }
1362 |       variable_initializers C_TK variable_initializer
1363                 {
1364                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1365                 }
1366 |       variable_initializers C_TK error
1367                 {yyerror ("Missing term"); RECOVER;}
1368 ;
1369
1370 /* 19.11 Production from 14: Blocks and Statements  */
1371 block:
1372         block_begin block_end
1373                 { $$ = $2; }
1374 |       block_begin block_statements block_end
1375                 { $$ = $3; }
1376 ;
1377
1378 block_begin:
1379         OCB_TK
1380                 { enter_block (); }
1381 ;
1382
1383 block_end:
1384         CCB_TK
1385                 {
1386                   maybe_absorb_scoping_blocks ();
1387                   $$ = exit_block ();
1388                   if (!BLOCK_SUBBLOCKS ($$))
1389                     BLOCK_SUBBLOCKS ($$) = build_java_empty_stmt ();
1390                 }
1391 ;
1392
1393 block_statements:
1394         block_statement
1395 |       block_statements block_statement
1396 ;
1397
1398 block_statement:
1399         local_variable_declaration_statement
1400 |       statement
1401                 { java_method_add_stmt (current_function_decl, $1); }
1402 |       class_declaration       /* Added, JDK1.1 local classes */
1403                 {
1404                   LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1405                   end_class_declaration (1);
1406                 }
1407 ;
1408
1409 local_variable_declaration_statement:
1410         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1411 ;
1412
1413 local_variable_declaration:
1414         type variable_declarators
1415                 { declare_local_variables (0, $1, $2); }
1416 |       final type variable_declarators /* Added, JDK1.1 final locals */
1417                 { declare_local_variables ($1, $2, $3); }
1418 ;
1419
1420 statement:
1421         statement_without_trailing_substatement
1422 |       labeled_statement
1423 |       if_then_statement
1424 |       if_then_else_statement
1425 |       while_statement
1426 |       for_statement
1427                 { $$ = exit_block (); }
1428 ;
1429
1430 statement_nsi:
1431         statement_without_trailing_substatement
1432 |       labeled_statement_nsi
1433 |       if_then_else_statement_nsi
1434 |       while_statement_nsi
1435 |       for_statement_nsi
1436                 { $$ = exit_block (); }
1437 ;
1438
1439 statement_without_trailing_substatement:
1440         block
1441 |       empty_statement
1442 |       expression_statement
1443 |       switch_statement
1444 |       do_statement
1445 |       break_statement
1446 |       continue_statement
1447 |       return_statement
1448 |       synchronized_statement
1449 |       throw_statement
1450 |       try_statement
1451 |       assert_statement
1452 ;
1453
1454 empty_statement:
1455         SC_TK
1456                 {
1457                   if (flag_extraneous_semicolon
1458                       && ! current_static_block
1459                       && (! current_function_decl ||
1460                           /* Verify we're not in a inner class declaration */
1461                           (GET_CPC () != TYPE_NAME
1462                            (DECL_CONTEXT (current_function_decl)))))
1463
1464                     {
1465 #ifdef USE_MAPPED_LOCATION
1466                       SET_EXPR_LOCATION (wfl_operator, input_location);
1467 #else
1468                       EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1469 #endif
1470                       parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1471                     }
1472                   $$ = build_java_empty_stmt ();
1473                 }
1474 ;
1475
1476 label_decl:
1477         identifier REL_CL_TK
1478                 {
1479                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1480                                             EXPR_WFL_NODE ($1));
1481                   pushlevel (2);
1482                   push_labeled_block ($$);
1483                   PUSH_LABELED_BLOCK ($$);
1484                 }
1485 ;
1486
1487 labeled_statement:
1488         label_decl statement
1489                 { $$ = finish_labeled_statement ($1, $2); }
1490 |       identifier error
1491                 {yyerror ("':' expected"); RECOVER;}
1492 ;
1493
1494 labeled_statement_nsi:
1495         label_decl statement_nsi
1496                 { $$ = finish_labeled_statement ($1, $2); }
1497 ;
1498
1499 /* We concentrate here a bunch of error handling rules that we couldn't write
1500    earlier, because expression_statement catches a missing ';'.  */
1501 expression_statement:
1502         statement_expression SC_TK
1503                 {
1504                   /* We have a statement. Generate a WFL around it so
1505                      we can debug it */
1506 #ifdef USE_MAPPED_LOCATION
1507                   $$ = expr_add_location ($1, input_location, 1);
1508 #else
1509                   $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1510                   JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1511 #endif
1512                   /* We know we have a statement, so set the debug
1513                      info to be eventually generate here. */
1514                 }
1515 |       error SC_TK
1516                 {
1517                   YYNOT_TWICE yyerror ("Invalid expression statement");
1518                   DRECOVER (expr_stmt);
1519                 }
1520 |       error OCB_TK
1521                 {
1522                   YYNOT_TWICE yyerror ("Invalid expression statement");
1523                   DRECOVER (expr_stmt);
1524                 }
1525 |       error CCB_TK
1526                 {
1527                   YYNOT_TWICE yyerror ("Invalid expression statement");
1528                   DRECOVER (expr_stmt);
1529                 }
1530 |       this_or_super OP_TK error
1531                 {yyerror ("')' expected"); RECOVER;}
1532 |       this_or_super OP_TK CP_TK error
1533                 {
1534                   parse_ctor_invocation_error ();
1535                   RECOVER;
1536                 }
1537 |       this_or_super OP_TK argument_list error
1538                 {yyerror ("')' expected"); RECOVER;}
1539 |       this_or_super OP_TK argument_list CP_TK error
1540                 {
1541                   parse_ctor_invocation_error ();
1542                   RECOVER;
1543                 }
1544 |       name DOT_TK SUPER_TK error
1545                 {yyerror ("'(' expected"); RECOVER;}
1546 |       name DOT_TK SUPER_TK OP_TK error
1547                 {yyerror ("')' expected"); RECOVER;}
1548 |       name DOT_TK SUPER_TK OP_TK argument_list error
1549                 {yyerror ("')' expected"); RECOVER;}
1550 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1551                 {yyerror ("';' expected"); RECOVER;}
1552 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1553                 {yyerror ("';' expected"); RECOVER;}
1554 ;
1555
1556 statement_expression:
1557         assignment
1558 |       pre_increment_expression
1559 |       pre_decrement_expression
1560 |       post_increment_expression
1561 |       post_decrement_expression
1562 |       method_invocation
1563 |       class_instance_creation_expression
1564 ;
1565
1566 if_then_statement:
1567         IF_TK OP_TK expression CP_TK statement
1568                 {
1569                   $$ = build_if_else_statement ($2.location, $3,
1570                                                 $5, NULL_TREE);
1571                 }
1572 |       IF_TK error
1573                 {yyerror ("'(' expected"); RECOVER;}
1574 |       IF_TK OP_TK error
1575                 {yyerror ("Missing term"); RECOVER;}
1576 |       IF_TK OP_TK expression error
1577                 {yyerror ("')' expected"); RECOVER;}
1578 ;
1579
1580 if_then_else_statement:
1581         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1582                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1583 ;
1584
1585 if_then_else_statement_nsi:
1586         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1587                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1588 ;
1589
1590 switch_statement:
1591         switch_expression
1592                 {
1593                   enter_block ();
1594                 }
1595         switch_block
1596                 {
1597                   /* Make into "proper list" of COMPOUND_EXPRs.
1598                      I.e. make the last statement also have its own
1599                      COMPOUND_EXPR. */
1600                   maybe_absorb_scoping_blocks ();
1601                   TREE_OPERAND ($1, 1) = exit_block ();
1602                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1603                 }
1604 ;
1605
1606 switch_expression:
1607         SWITCH_TK OP_TK expression CP_TK
1608                 {
1609                   $$ = build3 (SWITCH_EXPR, NULL_TREE, $3,
1610                                NULL_TREE, NULL_TREE);
1611                   SET_EXPR_LOCATION_FROM_TOKEN ($$, $2);
1612                 }
1613 |       SWITCH_TK error
1614                 {yyerror ("'(' expected"); RECOVER;}
1615 |       SWITCH_TK OP_TK error
1616                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1617 |       SWITCH_TK OP_TK expression CP_TK error
1618                 {yyerror ("'{' expected"); RECOVER;}
1619 ;
1620
1621 /* Default assignment is there to avoid type node on switch_block
1622    node. */
1623
1624 switch_block:
1625         OCB_TK CCB_TK
1626                 { $$ = NULL_TREE; }
1627 |       OCB_TK switch_labels CCB_TK
1628                 { $$ = NULL_TREE; }
1629 |       OCB_TK switch_block_statement_groups CCB_TK
1630                 { $$ = NULL_TREE; }
1631 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1632                 { $$ = NULL_TREE; }
1633 ;
1634
1635 switch_block_statement_groups:
1636         switch_block_statement_group
1637 |       switch_block_statement_groups switch_block_statement_group
1638 ;
1639
1640 switch_block_statement_group:
1641         switch_labels block_statements
1642 ;
1643
1644 switch_labels:
1645         switch_label
1646 |       switch_labels switch_label
1647 ;
1648
1649 switch_label:
1650         CASE_TK constant_expression REL_CL_TK
1651                 {
1652                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1653                   SET_EXPR_LOCATION_FROM_TOKEN (lab, $1);
1654                   java_method_add_stmt (current_function_decl, lab);
1655                 }
1656 |       DEFAULT_TK REL_CL_TK
1657                 {
1658                   tree lab = make_node (DEFAULT_EXPR);
1659                   SET_EXPR_LOCATION_FROM_TOKEN (lab, $1);
1660                   java_method_add_stmt (current_function_decl, lab);
1661                 }
1662 |       CASE_TK error
1663                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1664 |       CASE_TK constant_expression error
1665                 {yyerror ("':' expected"); RECOVER;}
1666 |       DEFAULT_TK error
1667                 {yyerror ("':' expected"); RECOVER;}
1668 ;
1669
1670 while_expression:
1671         WHILE_TK OP_TK expression CP_TK
1672                 {
1673                   tree body = build_loop_body ($2.location, $3, 0);
1674                   $$ = build_new_loop (body);
1675                 }
1676 ;
1677
1678 while_statement:
1679         while_expression statement
1680                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1681 |       WHILE_TK error
1682                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1683 |       WHILE_TK OP_TK error
1684                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1685 |       WHILE_TK OP_TK expression error
1686                 {yyerror ("')' expected"); RECOVER;}
1687 ;
1688
1689 while_statement_nsi:
1690         while_expression statement_nsi
1691                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1692 ;
1693
1694 do_statement_begin:
1695         DO_TK
1696                 {
1697                   tree body = build_loop_body (0, NULL_TREE, 1);
1698                   $$ = build_new_loop (body);
1699                 }
1700         /* Need error handing here. FIXME */
1701 ;
1702
1703 do_statement:
1704         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1705                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1706 ;
1707
1708 for_statement:
1709         for_begin SC_TK expression SC_TK for_update CP_TK statement
1710                 {
1711                   if (CONSTANT_CLASS_P ($3))
1712                     $3 = build_wfl_node ($3);
1713                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1714                 }
1715 |       for_begin SC_TK SC_TK for_update CP_TK statement
1716                 {
1717                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1718                   /* We have not condition, so we get rid of the EXIT_EXPR */
1719                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1720                     build_java_empty_stmt ();
1721                 }
1722 |       for_begin SC_TK error
1723                 {yyerror ("Invalid control expression"); RECOVER;}
1724 |       for_begin SC_TK expression SC_TK error
1725                 {yyerror ("Invalid update expression"); RECOVER;}
1726 |       for_begin SC_TK SC_TK error
1727                 {yyerror ("Invalid update expression"); RECOVER;}
1728 ;
1729
1730 for_statement_nsi:
1731         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1732                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1733 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1734                 {
1735                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1736                   /* We have not condition, so we get rid of the EXIT_EXPR */
1737                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1738                     build_java_empty_stmt ();
1739                 }
1740 ;
1741
1742 for_header:
1743         FOR_TK OP_TK
1744                 {
1745                   /* This scope defined for local variable that may be
1746                      defined within the scope of the for loop */
1747                   enter_block ();
1748                 }
1749 |       FOR_TK error
1750                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1751 |       FOR_TK OP_TK error
1752                 {yyerror ("Invalid init statement"); RECOVER;}
1753 ;
1754
1755 for_begin:
1756         for_header for_init
1757                 {
1758                   /* We now declare the loop body. The loop is
1759                      declared as a for loop. */
1760                   tree body = build_loop_body (0, NULL_TREE, 0);
1761                   $$ =  build_new_loop (body);
1762                   FOR_LOOP_P ($$) = 1;
1763                   /* The loop is added to the current block the for
1764                      statement is defined within */
1765                   java_method_add_stmt (current_function_decl, $$);
1766                 }
1767 ;
1768 for_init:                       /* Can be empty */
1769                 { $$ = build_java_empty_stmt (); }
1770 |       statement_expression_list
1771                 {
1772                   /* Init statement recorded within the previously
1773                      defined block scope */
1774                   $$ = java_method_add_stmt (current_function_decl, $1);
1775                 }
1776 |       local_variable_declaration
1777                 {
1778                   /* Local variable are recorded within the previously
1779                      defined block scope */
1780                   $$ = NULL_TREE;
1781                 }
1782 |       statement_expression_list error
1783                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1784 ;
1785
1786 for_update:                     /* Can be empty */
1787                 {$$ = build_java_empty_stmt ();}
1788 |       statement_expression_list
1789                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1790 ;
1791
1792 statement_expression_list:
1793         statement_expression
1794                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1795 |       statement_expression_list C_TK statement_expression
1796                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1797 |       statement_expression_list C_TK error
1798                 {yyerror ("Missing term"); RECOVER;}
1799 ;
1800
1801 break_statement:
1802         BREAK_TK SC_TK
1803                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1804 |       BREAK_TK identifier SC_TK
1805                 { $$ = build_bc_statement ($1.location, 1, $2); }
1806 |       BREAK_TK error
1807                 {yyerror ("Missing term"); RECOVER;}
1808 |       BREAK_TK identifier error
1809                 {yyerror ("';' expected"); RECOVER;}
1810 ;
1811
1812 continue_statement:
1813         CONTINUE_TK SC_TK
1814                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1815 |       CONTINUE_TK identifier SC_TK
1816                 { $$ = build_bc_statement ($1.location, 0, $2); }
1817 |       CONTINUE_TK error
1818                 {yyerror ("Missing term"); RECOVER;}
1819 |       CONTINUE_TK identifier error
1820                 {yyerror ("';' expected"); RECOVER;}
1821 ;
1822
1823 return_statement:
1824         RETURN_TK SC_TK
1825                 { $$ = build_return ($1.location, NULL_TREE); }
1826 |       RETURN_TK expression SC_TK
1827                 { $$ = build_return ($1.location, $2); }
1828 |       RETURN_TK error
1829                 {yyerror ("Missing term"); RECOVER;}
1830 |       RETURN_TK expression error
1831                 {yyerror ("';' expected"); RECOVER;}
1832 ;
1833
1834 throw_statement:
1835         THROW_TK expression SC_TK
1836                 {
1837                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1838                   SET_EXPR_LOCATION_FROM_TOKEN ($$, $1);
1839                 }
1840 |       THROW_TK error
1841                 {yyerror ("Missing term"); RECOVER;}
1842 |       THROW_TK expression error
1843                 {yyerror ("';' expected"); RECOVER;}
1844 ;
1845
1846 assert_statement:
1847         ASSERT_TK expression REL_CL_TK expression SC_TK
1848                 {
1849                   $$ = build_assertion ($1.location, $2, $4);
1850                 }
1851 |       ASSERT_TK expression SC_TK
1852                 {
1853                   $$ = build_assertion ($1.location, $2, NULL_TREE);
1854                 }
1855 |       ASSERT_TK error
1856                 {yyerror ("Missing term"); RECOVER;}
1857 |       ASSERT_TK expression error
1858                 {yyerror ("';' expected"); RECOVER;}
1859 ;
1860
1861 synchronized_statement:
1862         synchronized OP_TK expression CP_TK block
1863                 {
1864                   $$ = build2 (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1865                   EXPR_WFL_LINECOL ($$) =
1866                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1867                 }
1868 |       synchronized OP_TK expression CP_TK error
1869                 {yyerror ("'{' expected"); RECOVER;}
1870 |       synchronized error
1871                 {yyerror ("'(' expected"); RECOVER;}
1872 |       synchronized OP_TK error CP_TK
1873                 {yyerror ("Missing term"); RECOVER;}
1874 |       synchronized OP_TK error
1875                 {yyerror ("Missing term"); RECOVER;}
1876 ;
1877
1878 synchronized:
1879         modifiers
1880                 {
1881                   check_modifiers (
1882              "Illegal modifier %qs. Only %<synchronized%> was expected here",
1883                                    $1, ACC_SYNCHRONIZED);
1884                   if ($1 != ACC_SYNCHRONIZED)
1885                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1886                       build_wfl_node (NULL_TREE);
1887                 }
1888 ;
1889
1890 try_statement:
1891         TRY_TK block catches
1892                 { $$ = build_try_statement ($1.location, $2, $3); }
1893 |       TRY_TK block finally
1894                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1895 |       TRY_TK block catches finally
1896                 { $$ = build_try_finally_statement
1897                     ($1.location, build_try_statement ($1.location,
1898                                                        $2, $3), $4);
1899                 }
1900 |       TRY_TK error
1901                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1902 ;
1903
1904 catches:
1905         catch_clause
1906 |       catches catch_clause
1907                 {
1908                   TREE_CHAIN ($2) = $1;
1909                   $$ = $2;
1910                 }
1911 ;
1912
1913 catch_clause:
1914         catch_clause_parameter block
1915                 {
1916                   java_method_add_stmt (current_function_decl, $2);
1917                   exit_block ();
1918                   $$ = $1;
1919                 }
1920 ;
1921
1922 catch_clause_parameter:
1923         CATCH_TK OP_TK formal_parameter CP_TK
1924                 {
1925                   /* We add a block to define a scope for
1926                      formal_parameter (CCBP). The formal parameter is
1927                      declared initialized by the appropriate function
1928                      call */
1929                   tree ccpb;
1930                   tree init;
1931                   if ($3)
1932                     {
1933                       ccpb = enter_block ();
1934                       init = build_assignment
1935                         (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1936                          build0 (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1937                       declare_local_variables (0, TREE_VALUE ($3),
1938                                                build_tree_list
1939                                                (TREE_PURPOSE ($3), init));
1940                       $$ = build1 (JAVA_CATCH_EXPR, NULL_TREE, ccpb);
1941                       SET_EXPR_LOCATION_FROM_TOKEN ($$, $1);
1942                     }
1943                   else
1944                     {
1945                       $$ = error_mark_node;
1946                     }
1947                 }
1948 |       CATCH_TK error
1949                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1950 |       CATCH_TK OP_TK error
1951                 {
1952                   yyerror ("Missing term or ')' expected");
1953                   RECOVER; $$ = NULL_TREE;
1954                 }
1955 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1956                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1957 ;
1958
1959 finally:
1960         FINALLY_TK block
1961                 { $$ = $2; }
1962 |       FINALLY_TK error
1963                 {yyerror ("'{' expected"); RECOVER; }
1964 ;
1965
1966 /* 19.12 Production from 15: Expressions  */
1967 primary:
1968         primary_no_new_array
1969 |       array_creation_uninitialized
1970 |       array_creation_initialized
1971 ;
1972
1973 primary_no_new_array:
1974         literal
1975 |       THIS_TK
1976                 { $$ = build_this ($1.location); }
1977 |       OP_TK expression CP_TK
1978                 {$$ = $2;}
1979 |       class_instance_creation_expression
1980 |       field_access
1981 |       method_invocation
1982 |       array_access
1983 |       type_literals
1984         /* Added, JDK1.1 inner classes. Documentation is wrong
1985            referring to a 'ClassName' (class_name) rule that doesn't
1986            exist. Used name: instead.  */
1987 |       name DOT_TK THIS_TK
1988                 {
1989                   tree wfl = build_wfl_node (this_identifier_node);
1990                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1991                 }
1992 |       OP_TK expression error
1993                 {yyerror ("')' expected"); RECOVER;}
1994 |       name DOT_TK error
1995                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1996 |       primitive_type DOT_TK error
1997                 {yyerror ("'class' expected" ); RECOVER;}
1998 |       VOID_TK DOT_TK error
1999                 {yyerror ("'class' expected" ); RECOVER;}
2000 ;
2001
2002 type_literals:
2003         name DOT_TK CLASS_TK
2004                 { $$ = build_incomplete_class_ref ($2.location, $1); }
2005 |       array_type DOT_TK CLASS_TK
2006                 { $$ = build_incomplete_class_ref ($2.location, $1); }
2007 |       primitive_type DOT_TK CLASS_TK
2008                 { $$ = build_incomplete_class_ref ($2.location, $1); }
2009 |       VOID_TK DOT_TK CLASS_TK
2010                 {
2011                    $$ = build_incomplete_class_ref ($2.location,
2012                                                    void_type_node);
2013                 }
2014 ;
2015
2016 class_instance_creation_expression:
2017         NEW_TK class_type OP_TK argument_list CP_TK
2018                 { $$ = build_new_invocation ($2, $4); }
2019 |       NEW_TK class_type OP_TK CP_TK
2020                 { $$ = build_new_invocation ($2, NULL_TREE); }
2021 |       anonymous_class_creation
2022         /* Added, JDK1.1 inner classes, modified to use name or
2023            primary instead of primary solely which couldn't work in
2024            all situations.  */
2025 |       something_dot_new identifier OP_TK CP_TK
2026                 {
2027                   tree ctor = build_new_invocation ($2, NULL_TREE);
2028                   $$ = make_qualified_primary ($1, ctor,
2029                                                EXPR_WFL_LINECOL ($1));
2030                 }
2031 |       something_dot_new identifier OP_TK CP_TK class_body
2032 |       something_dot_new identifier OP_TK argument_list CP_TK
2033                 {
2034                   tree ctor = build_new_invocation ($2, $4);
2035                   $$ = make_qualified_primary ($1, ctor,
2036                                                EXPR_WFL_LINECOL ($1));
2037                 }
2038 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2039 |       NEW_TK error SC_TK
2040                 {$$ = NULL_TREE; yyerror ("'(' expected"); DRECOVER(new_1);}
2041 |       NEW_TK class_type error
2042                 {$$ = NULL_TREE; yyerror ("'(' expected"); RECOVER;}
2043 |       NEW_TK class_type OP_TK error
2044                 {$$ = NULL_TREE; yyerror ("')' or term expected"); RECOVER;}
2045 |       NEW_TK class_type OP_TK argument_list error
2046                 {$$ = NULL_TREE; yyerror ("')' expected"); RECOVER;}
2047 |       something_dot_new error
2048                 {
2049                   $$ = NULL_TREE;
2050                   YYERROR_NOW;
2051                   yyerror ("Identifier expected");
2052                   RECOVER;
2053                 }
2054 |       something_dot_new identifier error
2055                 {$$ = NULL_TREE; yyerror ("'(' expected"); RECOVER;}
2056 ;
2057
2058 /* Created after JDK1.1 rules originally added to
2059    class_instance_creation_expression, but modified to use
2060    'class_type' instead of 'TypeName' (type_name) which is mentioned
2061    in the documentation but doesn't exist. */
2062
2063 anonymous_class_creation:
2064         NEW_TK class_type OP_TK argument_list CP_TK
2065                 { create_anonymous_class ($2); }
2066         class_body
2067                 {
2068                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2069                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2070
2071                   end_class_declaration (1);
2072
2073                   /* Now we can craft the new expression */
2074                   $$ = build_new_invocation (id, $4);
2075
2076                   /* Note that we can't possibly be here if
2077                      `class_type' is an interface (in which case the
2078                      anonymous class extends Object and implements
2079                      `class_type', hence its constructor can't have
2080                      arguments.) */
2081
2082                   /* Otherwise, the innerclass must feature a
2083                      constructor matching `argument_list'. Anonymous
2084                      classes are a bit special: it's impossible to
2085                      define constructor for them, hence constructors
2086                      must be generated following the hints provided by
2087                      the `new' expression. Whether a super constructor
2088                      of that nature exists or not is to be verified
2089                      later on in verify_constructor_super.
2090
2091                      It's during the expansion of a `new' statement
2092                      referring to an anonymous class that a ctor will
2093                      be generated for the anonymous class, with the
2094                      right arguments. */
2095
2096                 }
2097 |       NEW_TK class_type OP_TK CP_TK
2098                 { create_anonymous_class ($2); }
2099         class_body
2100                 {
2101                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2102                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2103
2104                   end_class_declaration (1);
2105
2106                   /* Now we can craft the new expression. The
2107                      statement doesn't need to be remember so that a
2108                      constructor can be generated, since its signature
2109                      is already known. */
2110                   $$ = build_new_invocation (id, NULL_TREE);
2111                 }
2112 ;
2113
2114 something_dot_new:              /* Added, not part of the specs. */
2115         name DOT_TK NEW_TK
2116                 { $$ = $1; }
2117 |       primary DOT_TK NEW_TK
2118                 { $$ = $1; }
2119 ;
2120
2121 argument_list:
2122         expression
2123                 {
2124                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2125                   ctxp->formal_parameter_number = 1;
2126                 }
2127 |       argument_list C_TK expression
2128                 {
2129                   ctxp->formal_parameter_number += 1;
2130                   $$ = tree_cons (NULL_TREE, $3, $1);
2131                 }
2132 |       argument_list C_TK error
2133                 {yyerror ("Missing term"); RECOVER;}
2134 ;
2135
2136 array_creation_uninitialized:
2137         NEW_TK primitive_type dim_exprs
2138                 { $$ = build_newarray_node ($2, $3, 0); }
2139 |       NEW_TK class_or_interface_type dim_exprs
2140                 { $$ = build_newarray_node ($2, $3, 0); }
2141 |       NEW_TK primitive_type dim_exprs dims
2142                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2143 |       NEW_TK class_or_interface_type dim_exprs dims
2144                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2145 |       NEW_TK error CSB_TK
2146                 {yyerror ("'[' expected"); DRECOVER ("]");}
2147 |       NEW_TK error OSB_TK
2148                 {yyerror ("']' expected"); RECOVER;}
2149 ;
2150
2151 array_creation_initialized:
2152         /* Added, JDK1.1 anonymous array. Initial documentation rule
2153            modified */
2154         NEW_TK class_or_interface_type dims array_initializer
2155                 {
2156                   char *sig;
2157                   int osb = pop_current_osb (ctxp);
2158                   while (osb--)
2159                     obstack_grow (&temporary_obstack, "[]", 2);
2160                   obstack_1grow (&temporary_obstack, '\0');
2161                   sig = obstack_finish (&temporary_obstack);
2162                   $$ = build3 (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2163                                $2, get_identifier (sig), $4);
2164                 }
2165 |       NEW_TK primitive_type dims array_initializer
2166                 {
2167                   int osb = pop_current_osb (ctxp);
2168                   tree type = $2;
2169                   while (osb--)
2170                     type = build_java_array_type (type, -1);
2171                   $$ = build3 (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2172                                build_pointer_type (type), NULL_TREE, $4);
2173                 }
2174 |       NEW_TK error CSB_TK
2175                 {yyerror ("'[' expected"); DRECOVER ("]");}
2176 |       NEW_TK error OSB_TK
2177                 {yyerror ("']' expected"); RECOVER;}
2178 ;
2179
2180 dim_exprs:
2181         dim_expr
2182                 { $$ = build_tree_list (NULL_TREE, $1); }
2183 |       dim_exprs dim_expr
2184                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2185 ;
2186
2187 dim_expr:
2188         OSB_TK expression CSB_TK
2189                 {
2190                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2191                     {
2192                       $2 = build_wfl_node ($2);
2193                       TREE_TYPE ($2) = NULL_TREE;
2194                     }
2195                   EXPR_WFL_LINECOL ($2) = $1.location;
2196                   $$ = $2;
2197                 }
2198 |       OSB_TK expression error
2199                 {yyerror ("']' expected"); RECOVER;}
2200 |       OSB_TK error
2201                 {
2202                   yyerror ("Missing term");
2203                   yyerror ("']' expected");
2204                   RECOVER;
2205                 }
2206 ;
2207
2208 dims:
2209         OSB_TK CSB_TK
2210                 {
2211                   int allocate = 0;
2212                   /* If not initialized, allocate memory for the osb
2213                      numbers stack */
2214                   if (!ctxp->osb_limit)
2215                     {
2216                       allocate = ctxp->osb_limit = 32;
2217                       ctxp->osb_depth = -1;
2218                     }
2219                   /* If capacity overflown, reallocate a bigger chunk */
2220                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2221                     allocate = ctxp->osb_limit << 1;
2222
2223                   if (allocate)
2224                     {
2225                       allocate *= sizeof (int);
2226                       if (ctxp->osb_number)
2227                         ctxp->osb_number = xrealloc (ctxp->osb_number,
2228                                                      allocate);
2229                       else
2230                         ctxp->osb_number = xmalloc (allocate);
2231                     }
2232                   ctxp->osb_depth++;
2233                   CURRENT_OSB (ctxp) = 1;
2234                 }
2235 |       dims OSB_TK CSB_TK
2236                 { CURRENT_OSB (ctxp)++; }
2237 |       dims OSB_TK error
2238                 { yyerror ("']' expected"); RECOVER;}
2239 ;
2240
2241 field_access:
2242         primary DOT_TK identifier
2243                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2244                 /*  FIXME - REWRITE TO:
2245                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2246 |       SUPER_TK DOT_TK identifier
2247                 {
2248                   tree super_wfl = build_wfl_node (super_identifier_node);
2249                   SET_EXPR_LOCATION_FROM_TOKEN (super_wfl, $1);
2250                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2251                 }
2252 |       SUPER_TK error
2253                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2254 ;
2255
2256 method_invocation:
2257         name OP_TK CP_TK
2258                 { $$ = build_method_invocation ($1, NULL_TREE); }
2259 |       name OP_TK argument_list CP_TK
2260                 { $$ = build_method_invocation ($1, $3); }
2261 |       primary DOT_TK identifier OP_TK CP_TK
2262                 {
2263                   if (TREE_CODE ($1) == THIS_EXPR)
2264                     $$ = build_this_super_qualified_invocation
2265                       (1, $3, NULL_TREE, 0, $2.location);
2266                   else
2267                     {
2268                       tree invok = build_method_invocation ($3, NULL_TREE);
2269                       $$ = make_qualified_primary ($1, invok, $2.location);
2270                     }
2271                 }
2272 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2273                 {
2274                   if (TREE_CODE ($1) == THIS_EXPR)
2275                     $$ = build_this_super_qualified_invocation
2276                       (1, $3, $5, 0, $2.location);
2277                   else
2278                     {
2279                       tree invok = build_method_invocation ($3, $5);
2280                       $$ = make_qualified_primary ($1, invok, $2.location);
2281                     }
2282                 }
2283 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2284                 {
2285                   $$ = build_this_super_qualified_invocation
2286                     (0, $3, NULL_TREE, $1.location, $2.location);
2287                 }
2288 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2289                 {
2290                   $$ = build_this_super_qualified_invocation
2291                     (0, $3, $5, $1.location, $2.location);
2292                 }
2293         /* Screws up thing. I let it here until I'm convinced it can
2294            be removed. FIXME
2295 |       primary DOT_TK error
2296                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2297 |       SUPER_TK DOT_TK error CP_TK
2298                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2299 |       SUPER_TK DOT_TK error DOT_TK
2300                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2301 ;
2302
2303 array_access:
2304         name OSB_TK expression CSB_TK
2305                 { $$ = build_array_ref ($2.location, $1, $3); }
2306 |       primary_no_new_array OSB_TK expression CSB_TK
2307                 { $$ = build_array_ref ($2.location, $1, $3); }
2308 |       array_creation_initialized OSB_TK expression CSB_TK
2309                 { $$ = build_array_ref ($2.location, $1, $3); }
2310 |       name OSB_TK error
2311                 {
2312                   yyerror ("Missing term and ']' expected");
2313                   DRECOVER(array_access);
2314                 }
2315 |       name OSB_TK expression error
2316                 {
2317                   yyerror ("']' expected");
2318                   DRECOVER(array_access);
2319                 }
2320 |       primary_no_new_array OSB_TK error
2321                 {
2322                   yyerror ("Missing term and ']' expected");
2323                   DRECOVER(array_access);
2324                 }
2325 |       primary_no_new_array OSB_TK expression error
2326                 {
2327                   yyerror ("']' expected");
2328                   DRECOVER(array_access);
2329                 }
2330 |       array_creation_initialized OSB_TK error
2331                 {
2332                   yyerror ("Missing term and ']' expected");
2333                   DRECOVER(array_access);
2334                 }
2335 |       array_creation_initialized OSB_TK expression error
2336                 {
2337                   yyerror ("']' expected");
2338                   DRECOVER(array_access);
2339                 }
2340 ;
2341
2342 postfix_expression:
2343         primary
2344 |       name
2345 |       post_increment_expression
2346 |       post_decrement_expression
2347 ;
2348
2349 post_increment_expression:
2350         postfix_expression INCR_TK
2351                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2352 ;
2353
2354 post_decrement_expression:
2355         postfix_expression DECR_TK
2356                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2357 ;
2358
2359 trap_overflow_corner_case:
2360         pre_increment_expression
2361 |       pre_decrement_expression
2362 |       PLUS_TK unary_expression
2363                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2364 |       unary_expression_not_plus_minus
2365 |       PLUS_TK error
2366                 {yyerror ("Missing term"); RECOVER}
2367 ;
2368
2369 unary_expression:
2370         trap_overflow_corner_case
2371                 {
2372                   if ($1)
2373                     error_if_numeric_overflow ($1);
2374                   $$ = $1;
2375                 }
2376 |       MINUS_TK trap_overflow_corner_case
2377                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2378 |       MINUS_TK error
2379                 {yyerror ("Missing term"); RECOVER}
2380 ;
2381
2382 pre_increment_expression:
2383         INCR_TK unary_expression
2384                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2385 |       INCR_TK error
2386                 {yyerror ("Missing term"); RECOVER}
2387 ;
2388
2389 pre_decrement_expression:
2390         DECR_TK unary_expression
2391                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2392 |       DECR_TK error
2393                 {yyerror ("Missing term"); RECOVER}
2394 ;
2395
2396 unary_expression_not_plus_minus:
2397         postfix_expression
2398 |       NOT_TK unary_expression
2399                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2400 |       NEG_TK unary_expression
2401                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2402 |       cast_expression
2403 |       NOT_TK error
2404                 {yyerror ("Missing term"); RECOVER}
2405 |       NEG_TK error
2406                 {yyerror ("Missing term"); RECOVER}
2407 ;
2408
2409 cast_expression:                /* Error handling here is potentially weak */
2410         OP_TK primitive_type dims CP_TK unary_expression
2411                 {
2412                   tree type = $2;
2413                   int osb = pop_current_osb (ctxp);
2414                   while (osb--)
2415                     type = build_java_array_type (type, -1);
2416                   $$ = build_cast ($1.location, type, $5);
2417                 }
2418 |       OP_TK primitive_type CP_TK unary_expression
2419                 { $$ = build_cast ($1.location, $2, $4); }
2420 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2421                 { $$ = build_cast ($1.location, $2, $4); }
2422 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2423                 {
2424                   const char *ptr;
2425                   int osb = pop_current_osb (ctxp);
2426                   obstack_grow (&temporary_obstack,
2427                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2428                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2429                   while (osb--)
2430                     obstack_grow (&temporary_obstack, "[]", 2);
2431                   obstack_1grow (&temporary_obstack, '\0');
2432                   ptr = obstack_finish (&temporary_obstack);
2433                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2434                   $$ = build_cast ($1.location, $2, $5);
2435                 }
2436 |       OP_TK primitive_type OSB_TK error
2437                 {yyerror ("']' expected, invalid type expression");}
2438 |       OP_TK error
2439                 {
2440                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2441                   RECOVER;
2442                 }
2443 |       OP_TK primitive_type dims CP_TK error
2444                 {yyerror ("Missing term"); RECOVER;}
2445 |       OP_TK primitive_type CP_TK error
2446                 {yyerror ("Missing term"); RECOVER;}
2447 |       OP_TK name dims CP_TK error
2448                 {yyerror ("Missing term"); RECOVER;}
2449 ;
2450
2451 multiplicative_expression:
2452         unary_expression
2453 |       multiplicative_expression MULT_TK unary_expression
2454                 {
2455                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2456                                     $2.location, $1, $3);
2457                 }
2458 |       multiplicative_expression DIV_TK unary_expression
2459                 {
2460                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2461                                     $1, $3);
2462                 }
2463 |       multiplicative_expression REM_TK unary_expression
2464                 {
2465                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2466                                     $1, $3);
2467                 }
2468 |       multiplicative_expression MULT_TK error
2469                 {yyerror ("Missing term"); RECOVER;}
2470 |       multiplicative_expression DIV_TK error
2471                 {yyerror ("Missing term"); RECOVER;}
2472 |       multiplicative_expression REM_TK error
2473                 {yyerror ("Missing term"); RECOVER;}
2474 ;
2475
2476 additive_expression:
2477         multiplicative_expression
2478 |       additive_expression PLUS_TK multiplicative_expression
2479                 {
2480                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2481                                     $1, $3);
2482                 }
2483 |       additive_expression MINUS_TK multiplicative_expression
2484                 {
2485                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2486                                     $1, $3);
2487                 }
2488 |       additive_expression PLUS_TK error
2489                 {yyerror ("Missing term"); RECOVER;}
2490 |       additive_expression MINUS_TK error
2491                 {yyerror ("Missing term"); RECOVER;}
2492 ;
2493
2494 shift_expression:
2495         additive_expression
2496 |       shift_expression LS_TK additive_expression
2497                 {
2498                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2499                                     $1, $3);
2500                 }
2501 |       shift_expression SRS_TK additive_expression
2502                 {
2503                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2504                                     $1, $3);
2505                 }
2506 |       shift_expression ZRS_TK additive_expression
2507                 {
2508                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2509                                     $1, $3);
2510                 }
2511 |       shift_expression LS_TK error
2512                 {yyerror ("Missing term"); RECOVER;}
2513 |       shift_expression SRS_TK error
2514                 {yyerror ("Missing term"); RECOVER;}
2515 |       shift_expression ZRS_TK error
2516                 {yyerror ("Missing term"); RECOVER;}
2517 ;
2518
2519 relational_expression:
2520         shift_expression
2521 |       relational_expression LT_TK shift_expression
2522                 {
2523                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2524                                     $1, $3);
2525                 }
2526 |       relational_expression GT_TK shift_expression
2527                 {
2528                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2529                                     $1, $3);
2530                 }
2531 |       relational_expression LTE_TK shift_expression
2532                 {
2533                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2534                                     $1, $3);
2535                 }
2536 |       relational_expression GTE_TK shift_expression
2537                 {
2538                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2539                                     $1, $3);
2540                 }
2541 |       relational_expression INSTANCEOF_TK reference_type
2542                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2543 |       relational_expression LT_TK error
2544                 {yyerror ("Missing term"); RECOVER;}
2545 |       relational_expression GT_TK error
2546                 {yyerror ("Missing term"); RECOVER;}
2547 |       relational_expression LTE_TK error
2548                 {yyerror ("Missing term"); RECOVER;}
2549 |       relational_expression GTE_TK error
2550                 {yyerror ("Missing term"); RECOVER;}
2551 |       relational_expression INSTANCEOF_TK error
2552                 {yyerror ("Invalid reference type"); RECOVER;}
2553 ;
2554
2555 equality_expression:
2556         relational_expression
2557 |       equality_expression EQ_TK relational_expression
2558                 {
2559                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2560                                     $1, $3);
2561                 }
2562 |       equality_expression NEQ_TK relational_expression
2563                 {
2564                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2565                                     $1, $3);
2566                 }
2567 |       equality_expression EQ_TK error
2568                 {yyerror ("Missing term"); RECOVER;}
2569 |       equality_expression NEQ_TK error
2570                 {yyerror ("Missing term"); RECOVER;}
2571 ;
2572
2573 and_expression:
2574         equality_expression
2575 |       and_expression AND_TK equality_expression
2576                 {
2577                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2578                                     $1, $3);
2579                 }
2580 |       and_expression AND_TK error
2581                 {yyerror ("Missing term"); RECOVER;}
2582 ;
2583
2584 exclusive_or_expression:
2585         and_expression
2586 |       exclusive_or_expression XOR_TK and_expression
2587                 {
2588                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2589                                     $1, $3);
2590                 }
2591 |       exclusive_or_expression XOR_TK error
2592                 {yyerror ("Missing term"); RECOVER;}
2593 ;
2594
2595 inclusive_or_expression:
2596         exclusive_or_expression
2597 |       inclusive_or_expression OR_TK exclusive_or_expression
2598                 {
2599                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2600                                     $1, $3);
2601                 }
2602 |       inclusive_or_expression OR_TK error
2603                 {yyerror ("Missing term"); RECOVER;}
2604 ;
2605
2606 conditional_and_expression:
2607         inclusive_or_expression
2608 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2609                 {
2610                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2611                                     $1, $3);
2612                 }
2613 |       conditional_and_expression BOOL_AND_TK error
2614                 {yyerror ("Missing term"); RECOVER;}
2615 ;
2616
2617 conditional_or_expression:
2618         conditional_and_expression
2619 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2620                 {
2621                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2622                                     $1, $3);
2623                 }
2624 |       conditional_or_expression BOOL_OR_TK error
2625                 {yyerror ("Missing term"); RECOVER;}
2626 ;
2627
2628 conditional_expression:         /* Error handling here is weak */
2629         conditional_or_expression
2630 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2631                 {
2632                   $$ = build3 (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2633                   SET_EXPR_LOCATION_FROM_TOKEN ($$, $2);
2634                 }
2635 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2636                 {
2637                   YYERROR_NOW;
2638                   yyerror ("Missing term");
2639                   DRECOVER (1);
2640                 }
2641 |       conditional_or_expression REL_QM_TK error
2642                 {yyerror ("Missing term"); DRECOVER (2);}
2643 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2644                 {yyerror ("Missing term"); DRECOVER (3);}
2645 ;
2646
2647 assignment_expression:
2648         conditional_expression
2649 |       assignment
2650 ;
2651
2652 assignment:
2653         left_hand_side assignment_operator assignment_expression
2654                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2655 |       left_hand_side assignment_operator error
2656                 {
2657                   YYNOT_TWICE yyerror ("Missing term");
2658                   DRECOVER (assign);
2659                 }
2660 ;
2661
2662 left_hand_side:
2663         name
2664 |       field_access
2665 |       array_access
2666 ;
2667
2668 assignment_operator:
2669         ASSIGN_ANY_TK
2670 |       ASSIGN_TK
2671 ;
2672
2673 expression:
2674         assignment_expression
2675 ;
2676
2677 constant_expression:
2678         expression
2679 ;
2680
2681 %%
2682
2683 /* Helper function to retrieve an OSB count. Should be used when the
2684    `dims:' rule is being used.  */
2685
2686 static int
2687 pop_current_osb (struct parser_ctxt *ctxp)
2688 {
2689   int to_return;
2690
2691   if (ctxp->osb_depth < 0)
2692     abort ();
2693
2694   to_return = CURRENT_OSB (ctxp);
2695   ctxp->osb_depth--;
2696
2697   return to_return;
2698 }
2699
2700 \f
2701
2702 /* This section of the code deal with save/restoring parser contexts.
2703    Add mode documentation here. FIXME */
2704
2705 /* Helper function. Create a new parser context. With
2706    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2707    context is copied, otherwise, the new context is zeroed. The newly
2708    created context becomes the current one.  */
2709
2710 static void
2711 create_new_parser_context (int copy_from_previous)
2712 {
2713   struct parser_ctxt *new;
2714
2715   new = ggc_alloc (sizeof (struct parser_ctxt));
2716   if (copy_from_previous)
2717     {
2718       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2719       /* This flag, indicating the context saves global values,
2720          should only be set by java_parser_context_save_global.  */
2721       new->saved_data_ctx = 0;
2722     }
2723   else
2724     memset (new, 0, sizeof (struct parser_ctxt));
2725
2726   new->next = ctxp;
2727   ctxp = new;
2728 }
2729
2730 /* Create a new parser context and make it the current one. */
2731
2732 void
2733 java_push_parser_context (void)
2734 {
2735   create_new_parser_context (0);
2736 }
2737
2738 void
2739 java_pop_parser_context (int generate)
2740 {
2741   tree current;
2742   struct parser_ctxt *next;
2743
2744   if (!ctxp)
2745     return;
2746
2747   next = ctxp->next;
2748   if (next)
2749     {
2750       input_location = ctxp->save_location;
2751       current_class = ctxp->class_type;
2752     }
2753
2754   /* If the old and new lexers differ, then free the old one.  */
2755   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2756     java_destroy_lexer (ctxp->lexer);
2757
2758   /* Set the single import class file flag to 0 for the current list
2759      of imported things */
2760   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2761     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2762
2763   /* If we pushed a context to parse a class intended to be generated,
2764      we keep it so we can remember the class. What we could actually
2765      do is to just update a list of class names.  */
2766   if (generate)
2767     {
2768       ctxp->next = ctxp_for_generation;
2769       ctxp_for_generation = ctxp;
2770     }
2771
2772   /* And restore those of the previous context */
2773   if ((ctxp = next))            /* Assignment is really meant here */
2774     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2775       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2776 }
2777
2778 /* Create a parser context for the use of saving some global
2779    variables.  */
2780
2781 void
2782 java_parser_context_save_global (void)
2783 {
2784   if (!ctxp)
2785     {
2786       java_push_parser_context ();
2787       ctxp->saved_data_ctx = 1;
2788     }
2789
2790   /* If this context already stores data, create a new one suitable
2791      for data storage. */
2792   else if (ctxp->saved_data)
2793     {
2794       create_new_parser_context (1);
2795       ctxp->saved_data_ctx = 1;
2796     }
2797
2798   ctxp->save_location = input_location;
2799   ctxp->class_type = current_class;
2800   ctxp->function_decl = current_function_decl;
2801   ctxp->saved_data = 1;
2802 }
2803
2804 /* Restore some global variables from the previous context. Make the
2805    previous context the current one.  */
2806
2807 void
2808 java_parser_context_restore_global (void)
2809 {
2810   input_location = ctxp->save_location;
2811   current_class = ctxp->class_type;
2812   if (wfl_operator)
2813 #ifdef USE_MAPPED_LOCATION
2814     SET_EXPR_LOCATION (wfl_operator, ctxp->save_location);
2815 #else
2816     EXPR_WFL_FILENAME_NODE (wfl_operator) = get_identifier (input_filename);
2817 #endif
2818   current_function_decl = ctxp->function_decl;
2819   ctxp->saved_data = 0;
2820   if (ctxp->saved_data_ctx)
2821     java_pop_parser_context (0);
2822 }
2823
2824 /* Suspend vital data for the current class/function being parsed so
2825    that an other class can be parsed. Used to let local/anonymous
2826    classes be parsed.  */
2827
2828 static void
2829 java_parser_context_suspend (void)
2830 {
2831   /* This makes debugging through java_debug_context easier */
2832   static const char *const name = "<inner buffer context>";
2833
2834   /* Duplicate the previous context, use it to save the globals we're
2835      interested in */
2836   create_new_parser_context (1);
2837   ctxp->function_decl = current_function_decl;
2838   ctxp->class_type = current_class;
2839
2840   /* Then create a new context which inherits all data from the
2841      previous one. This will be the new current context  */
2842   create_new_parser_context (1);
2843
2844   /* Help debugging */
2845   ctxp->next->filename = name;
2846 }
2847
2848 /* Resume vital data for the current class/function being parsed so
2849    that an other class can be parsed. Used to let local/anonymous
2850    classes be parsed.  The trick is the data storing file position
2851    informations must be restored to their current value, so parsing
2852    can resume as if no context was ever saved. */
2853
2854 static void
2855 java_parser_context_resume (void)
2856 {
2857   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2858   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2859   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2860
2861   /* We need to inherit the list of classes to complete/generate */
2862   restored->classd_list = old->classd_list;
2863   restored->class_list = old->class_list;
2864
2865   /* Restore the current class and function from the saver */
2866   current_class = saver->class_type;
2867   current_function_decl = saver->function_decl;
2868
2869   /* Retrieve the restored context */
2870   ctxp = restored;
2871
2872   /* Re-installed the data for the parsing to carry on */
2873   memcpy (&ctxp->marker_begining, &old->marker_begining,
2874           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2875 }
2876
2877 /* Add a new anchor node to which all statement(s) initializing static
2878    and non static initialized upon declaration field(s) will be
2879    linked.  */
2880
2881 static void
2882 java_parser_context_push_initialized_field (void)
2883 {
2884   tree node;
2885
2886   node = build_tree_list (NULL_TREE, NULL_TREE);
2887   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2888   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2889
2890   node = build_tree_list (NULL_TREE, NULL_TREE);
2891   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2892   CPC_INITIALIZER_LIST (ctxp) = node;
2893
2894   node = build_tree_list (NULL_TREE, NULL_TREE);
2895   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2896   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2897 }
2898
2899 /* Pop the lists of initialized field. If this lists aren't empty,
2900    remember them so we can use it to create and populate the finit$
2901    or <clinit> functions. */
2902
2903 static void
2904 java_parser_context_pop_initialized_field (void)
2905 {
2906   tree stmts;
2907   tree class_type = TREE_TYPE (GET_CPC ());
2908
2909   if (CPC_INITIALIZER_LIST (ctxp))
2910     {
2911       stmts = CPC_INITIALIZER_STMT (ctxp);
2912       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2913       if (stmts && !java_error_count)
2914         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2915     }
2916
2917   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2918     {
2919       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2920       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2921         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2922       /* Keep initialization in order to enforce 8.5 */
2923       if (stmts && !java_error_count)
2924         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2925     }
2926
2927   /* JDK 1.1 instance initializers */
2928   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2929     {
2930       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2931       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2932         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2933       if (stmts && !java_error_count)
2934         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2935     }
2936 }
2937
2938 static tree
2939 reorder_static_initialized (tree list)
2940 {
2941   /* We have to keep things in order. The alias initializer have to
2942      come first, then the initialized regular field, in reverse to
2943      keep them in lexical order. */
2944   tree marker, previous = NULL_TREE;
2945   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2946     if (TREE_CODE (marker) == TREE_LIST
2947         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2948       break;
2949
2950   /* No static initialized, the list is fine as is */
2951   if (!previous)
2952     list = TREE_CHAIN (marker);
2953
2954   /* No marker? reverse the whole list */
2955   else if (!marker)
2956     list = nreverse (list);
2957
2958   /* Otherwise, reverse what's after the marker and the new reordered
2959      sublist will replace the marker. */
2960   else
2961     {
2962       TREE_CHAIN (previous) = NULL_TREE;
2963       list = nreverse (list);
2964       list = chainon (TREE_CHAIN (marker), list);
2965     }
2966   return list;
2967 }
2968
2969 /* Helper functions to dump the parser context stack.  */
2970
2971 #define TAB_CONTEXT(C) \
2972   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2973
2974 static void
2975 java_debug_context_do (int tab)
2976 {
2977   struct parser_ctxt *copy = ctxp;
2978   while (copy)
2979     {
2980       TAB_CONTEXT (tab);
2981       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2982       TAB_CONTEXT (tab);
2983       fprintf (stderr, "filename: %s\n", copy->filename);
2984       TAB_CONTEXT (tab);
2985       fprintf (stderr, "package: %s\n",
2986                (copy->package ?
2987                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2988       TAB_CONTEXT (tab);
2989       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2990       TAB_CONTEXT (tab);
2991       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2992       copy = copy->next;
2993       tab += 2;
2994     }
2995 }
2996
2997 /* Dump the stacked up parser contexts. Intended to be called from a
2998    debugger.  */
2999
3000 void
3001 java_debug_context (void)
3002 {
3003   java_debug_context_do (0);
3004 }
3005
3006 \f
3007
3008 /* Flag for the error report routine to issue the error the first time
3009    it's called (overriding the default behavior which is to drop the
3010    first invocation and honor the second one, taking advantage of a
3011    richer context.  */
3012 static int force_error = 0;
3013
3014 /* Reporting an constructor invocation error.  */
3015 static void
3016 parse_ctor_invocation_error (void)
3017 {
3018   if (DECL_CONSTRUCTOR_P (current_function_decl))
3019     yyerror ("Constructor invocation must be first thing in a constructor");
3020   else
3021     yyerror ("Only constructors can invoke constructors");
3022 }
3023
3024 /* Reporting JDK1.1 features not implemented.  */
3025
3026 static tree
3027 parse_jdk1_1_error (const char *msg)
3028 {
3029   sorry (": %qs JDK1.1(TM) feature", msg);
3030   java_error_count++;
3031   return build_java_empty_stmt ();
3032 }
3033
3034 static int do_warning = 0;
3035
3036 void
3037 yyerror (const char *msgid)
3038 {
3039 #ifdef USE_MAPPED_LOCATION
3040   static source_location elc;
3041   expanded_location xloc = expand_location (input_location);
3042   int current_line = xloc.line;
3043 #else
3044   static java_lc elc;
3045   int save_lineno;
3046   int current_line = input_line;
3047 #endif
3048   static int prev_lineno;
3049   static const char *prev_msg;
3050
3051   char *remainder, *code_from_source;
3052
3053   if (!force_error && prev_lineno == current_line)
3054     return;
3055 #ifndef USE_MAPPED_LOCATION
3056   current_line = ctxp->lexer->token_start.line;
3057 #endif
3058
3059   /* Save current error location but report latter, when the context is
3060      richer.  */
3061   if (ctxp->java_error_flag == 0)
3062     {
3063       ctxp->java_error_flag = 1;
3064 #ifdef USE_MAPPED_LOCATION
3065       elc = input_location;
3066 #else
3067       elc = ctxp->lexer->token_start;
3068 #endif
3069       /* Do something to use the previous line if we're reaching the
3070          end of the file... */
3071 #ifdef VERBOSE_SKELETON
3072       printf ("* Error detected (%s)\n", (msgid ? msgid : "(null)"));
3073 #endif
3074       return;
3075     }
3076
3077   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3078   if (!force_error && msgid == prev_msg && prev_lineno == current_line)
3079     return;
3080
3081   ctxp->java_error_flag = 0;
3082   if (do_warning)
3083     java_warning_count++;
3084   else
3085     java_error_count++;
3086
3087 #if 0 /* FIXME */
3088   if (elc.col == 0 && msgid && msgid[1] == ';')
3089     elc = ctxp->prev_line_end;
3090 #endif
3091
3092   prev_msg = msgid;
3093
3094 #ifdef USE_MAPPED_LOCATION
3095   prev_lineno = current_line;
3096   code_from_source = java_get_line_col (xloc.file, current_line, xloc.column);
3097 #else
3098   save_lineno = input_line;
3099   prev_lineno = input_line = current_line;
3100   code_from_source = java_get_line_col (input_filename, current_line,
3101                                         ctxp->lexer->token_start.col);
3102 #endif
3103
3104
3105   obstack_grow0 (&temporary_obstack,
3106                  code_from_source, strlen (code_from_source));
3107   remainder = obstack_finish (&temporary_obstack);
3108   if (do_warning)
3109     warning (0, "%s.\n%s", msgid, remainder);
3110   else
3111     error ("%s.\n%s", msgid, remainder);
3112
3113   /* This allow us to cheaply avoid an extra 'Invalid expression
3114      statement' error report when errors have been already reported on
3115      the same line. This occurs when we report an error but don't have
3116      a synchronization point other than ';', which
3117      expression_statement is the only one to take care of.  */
3118 #ifndef USE_MAPPED_LOCATION
3119   input_line = save_lineno;
3120 #endif
3121   ctxp->prevent_ese = input_line;
3122 }
3123
3124 static void
3125 issue_warning_error_from_context (
3126 #ifdef USE_MAPPED_LOCATION
3127                                   source_location cl,
3128 #else
3129                                   tree cl,
3130 #endif
3131                                   const char *msgid, va_list *ap)
3132 {
3133 #ifdef USE_MAPPED_LOCATION
3134   source_location saved_location = input_location;
3135   expanded_location xloc = expand_location (cl);
3136 #else
3137   java_lc save_lc = ctxp->lexer->token_start;
3138   const char *saved = ctxp->filename, *saved_input_filename;
3139 #endif
3140   char buffer [4096];
3141   text_info text;
3142
3143   text.err_no = errno;
3144   text.args_ptr = ap;
3145   text.format_spec = msgid;
3146   pp_format_text (global_dc->printer, &text);
3147   strncpy (buffer, pp_formatted_text (global_dc->printer), sizeof (buffer) - 1);
3148   buffer[sizeof (buffer) - 1] = '\0';
3149   pp_clear_output_area (global_dc->printer);
3150
3151   force_error = 1;
3152
3153 #ifdef USE_MAPPED_LOCATION
3154   if (xloc.file != NULL)
3155     {
3156       ctxp->filename = xloc.file;
3157       input_location = cl;
3158     }
3159 #else
3160   ctxp->lexer->token_start.line = EXPR_WFL_LINENO (cl);
3161   ctxp->lexer->token_start.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1
3162                                    : EXPR_WFL_COLNO (cl) == 0xffe ? -2
3163                                    : EXPR_WFL_COLNO (cl));
3164
3165   /* We have a CL, that's a good reason for using it if it contains data */
3166   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3167     ctxp->filename = EXPR_WFL_FILENAME (cl);
3168   saved_input_filename = input_filename;
3169   input_filename = ctxp->filename;
3170 #endif
3171   java_error (NULL);
3172   java_error (buffer);
3173 #ifdef USE_MAPPED_LOCATION
3174   input_location = saved_location;
3175 #else
3176   ctxp->filename = saved;
3177   input_filename = saved_input_filename;
3178   ctxp->lexer->token_start = save_lc;
3179 #endif
3180   force_error = 0;
3181 }
3182
3183 /* Issue an error message at a current source line CL.
3184    FUTURE/FIXME:  change cl to be a source_location. */
3185
3186 void
3187 parse_error_context (tree cl, const char *msgid, ...)
3188 {
3189   va_list ap;
3190   va_start (ap, msgid);
3191 #ifdef USE_MAPPED_LOCATION
3192   issue_warning_error_from_context (EXPR_LOCATION (cl), msgid, &ap);
3193 #else
3194   issue_warning_error_from_context (cl, msgid, &ap);
3195 #endif
3196   va_end (ap);
3197 }
3198
3199 /* Issue a warning at a current source line CL.
3200    FUTURE/FIXME:  change cl to be a source_location. */
3201
3202 static void
3203 parse_warning_context (tree cl, const char *msgid, ...)
3204 {
3205   va_list ap;
3206   va_start (ap, msgid);
3207
3208   do_warning = 1;
3209 #ifdef USE_MAPPED_LOCATION
3210   issue_warning_error_from_context (EXPR_LOCATION (cl), msgid, &ap);
3211 #else
3212   issue_warning_error_from_context (cl, msgid, &ap);
3213 #endif
3214   do_warning = 0;
3215   va_end (ap);
3216 }
3217
3218 static tree
3219 find_expr_with_wfl (tree node)
3220 {
3221   while (node)
3222     {
3223       enum tree_code_class code;
3224       tree to_return;
3225
3226       switch (TREE_CODE (node))
3227         {
3228         case BLOCK:
3229           node = BLOCK_EXPR_BODY (node);
3230           continue;
3231
3232         case COMPOUND_EXPR:
3233           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3234           if (to_return)
3235             return to_return;
3236           node = TREE_OPERAND (node, 1);
3237           continue;
3238
3239         case LOOP_EXPR:
3240           node = TREE_OPERAND (node, 0);
3241           continue;
3242
3243         case LABELED_BLOCK_EXPR:
3244           node = LABELED_BLOCK_BODY (node);
3245           continue;
3246
3247         default:
3248           code = TREE_CODE_CLASS (TREE_CODE (node));
3249           if (((code == tcc_unary) || (code == tcc_binary)
3250                || (code == tcc_expression))
3251               && EXPR_WFL_LINECOL (node))
3252             return node;
3253           return NULL_TREE;
3254         }
3255     }
3256   return NULL_TREE;
3257 }
3258
3259 /* Issue a missing return statement error. Uses METHOD to figure the
3260    last line of the method the error occurs in.  */
3261
3262 static void
3263 missing_return_error (tree method)
3264 {
3265 #ifdef USE_MAPPED_LOCATION
3266   SET_EXPR_LOCATION (wfl_operator, DECL_FUNCTION_LAST_LINE (method));
3267 #else
3268   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3269 #endif
3270   parse_error_context (wfl_operator, "Missing return statement");
3271 }
3272
3273 /* Issue an unreachable statement error. From NODE, find the next
3274    statement to report appropriately.  */
3275 static void
3276 unreachable_stmt_error (tree node)
3277 {
3278   /* Browse node to find the next expression node that has a WFL. Use
3279      the location to report the error */
3280   if (TREE_CODE (node) == COMPOUND_EXPR)
3281     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3282   else
3283     node = find_expr_with_wfl (node);
3284
3285   if (node)
3286     {
3287 #ifdef USE_MAPPED_LOCATION
3288       SET_EXPR_LOCATION (wfl_operator, EXPR_LOCATION (node));
3289 #else
3290       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3291 #endif
3292       parse_error_context (wfl_operator, "Unreachable statement");
3293     }
3294   else
3295     abort ();
3296 }
3297
3298 static int
3299 not_accessible_field_error (tree wfl, tree decl)
3300 {
3301   parse_error_context
3302     (wfl, "Can't access %s field %<%s.%s%> from %qs",
3303      accessibility_string (get_access_flags_from_decl (decl)),
3304      GET_TYPE_NAME (DECL_CONTEXT (decl)),
3305      IDENTIFIER_POINTER (DECL_NAME (decl)),
3306      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3307   return 1;
3308 }
3309
3310 int
3311 java_report_errors (void)
3312 {
3313   if (java_error_count)
3314     fprintf (stderr, "%d error%s",
3315              java_error_count, (java_error_count == 1 ? "" : "s"));
3316   if (java_warning_count)
3317     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3318              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3319   if (java_error_count || java_warning_count)
3320     putc ('\n', stderr);
3321   return java_error_count;
3322 }
3323
3324 static char *
3325 java_accstring_lookup (int flags)
3326 {
3327   static char buffer [80];
3328 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3329
3330   /* Access modifier looked-up first for easier report on forbidden
3331      access. */
3332   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3333   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3334   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3335   if (flags & ACC_STATIC) COPY_RETURN ("static");
3336   if (flags & ACC_FINAL) COPY_RETURN ("final");
3337   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3338   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3339   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3340   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3341   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3342   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3343
3344   buffer [0] = '\0';
3345   return buffer;
3346 #undef COPY_RETURN
3347 }
3348
3349 /* Returns a string denoting the accessibility of a class or a member as
3350    indicated by FLAGS.  We need a separate function from
3351    java_accstring_lookup, as the latter can return spurious "static", etc.
3352    if package-private access is defined (in which case none of the
3353    relevant access control bits in FLAGS is set).  */
3354
3355 static const char *
3356 accessibility_string (int flags)
3357 {
3358   if (flags & ACC_PRIVATE) return "private";
3359   if (flags & ACC_PROTECTED) return "protected";
3360   if (flags & ACC_PUBLIC) return "public";
3361
3362   return "package-private";
3363 }
3364
3365 /* Issuing error messages upon redefinition of classes, interfaces or
3366    variables. */
3367
3368 static void
3369 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3370 {
3371   parse_error_context (cl, "%s %qs already defined in %s:%d",
3372                        context, IDENTIFIER_POINTER (id),
3373                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3374   /* Here we should point out where its redefined. It's a unicode. FIXME */
3375 }
3376
3377 static void
3378 variable_redefinition_error (tree context, tree name, tree type, int line)
3379 {
3380   const char *type_name;
3381
3382   /* Figure a proper name for type. We might haven't resolved it */
3383   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3384     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3385   else
3386     type_name = lang_printable_name (type, 0);
3387
3388   parse_error_context (context,
3389                        "Variable %qs is already defined in this method and was declared %<%s %s%> at line %d",
3390                        IDENTIFIER_POINTER (name),
3391                        type_name, IDENTIFIER_POINTER (name), line);
3392 }
3393
3394 /* If ANAME is terminated with `[]', it indicates an array. This
3395    function returns the number of `[]' found and if this number is
3396    greater than zero, it extracts the array type name and places it in
3397    the node pointed to by TRIMMED unless TRIMMED is null.  */
3398
3399 static int
3400 build_type_name_from_array_name (tree aname, tree *trimmed)
3401 {
3402   const char *name = IDENTIFIER_POINTER (aname);
3403   int len = IDENTIFIER_LENGTH (aname);
3404   int array_dims;
3405
3406   STRING_STRIP_BRACKETS (name, len, array_dims);
3407
3408   if (array_dims && trimmed)
3409     *trimmed = get_identifier_with_length (name, len);
3410
3411   return array_dims;
3412 }
3413
3414 static tree
3415 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3416 {
3417   int more_dims = 0;
3418
3419   /* Eventually get more dims */
3420   more_dims = build_type_name_from_array_name (name, &name);
3421
3422   /* If we have, then craft a new type for this variable */
3423   if (more_dims)
3424     {
3425       tree save = type;
3426
3427       /* If we have a pointer, use its type */
3428       if (TREE_CODE (type) == POINTER_TYPE)
3429         type = TREE_TYPE (type);
3430
3431       /* Building the first dimension of a primitive type uses this
3432          function */
3433       if (JPRIMITIVE_TYPE_P (type))
3434         {
3435           type = build_java_array_type (type, -1);
3436           more_dims--;
3437         }
3438       /* Otherwise, if we have a WFL for this type, use it (the type
3439          is already an array on an unresolved type, and we just keep
3440          on adding dimensions) */
3441       else if (type_wfl)
3442         {
3443           type = type_wfl;
3444           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3445                                                         NULL);
3446         }
3447
3448       /* Add all the dimensions */
3449       while (more_dims--)
3450         type = build_unresolved_array_type (type);
3451
3452       /* The type may have been incomplete in the first place */
3453       if (type_wfl)
3454         type = obtain_incomplete_type (type);
3455     }
3456
3457   if (ret_name)
3458     *ret_name = name;
3459   return type;
3460 }
3461
3462 /* Build something that the type identifier resolver will identify as
3463    being an array to an unresolved type. TYPE_WFL is a WFL on a
3464    identifier. */
3465
3466 static tree
3467 build_unresolved_array_type (tree type_or_wfl)
3468 {
3469   const char *ptr;
3470   tree wfl;
3471
3472   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3473      just create a array type */
3474   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3475     return build_java_array_type (type_or_wfl, -1);
3476
3477   obstack_grow (&temporary_obstack,
3478                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3479                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3480   obstack_grow0 (&temporary_obstack, "[]", 2);
3481   ptr = obstack_finish (&temporary_obstack);
3482 #ifdef USE_MAPPED_LOCATION
3483   wfl = build_expr_wfl (get_identifier (ptr), EXPR_LOCATION (type_or_wfl));
3484 #else
3485   wfl = build_expr_wfl (get_identifier (ptr),
3486                         EXPR_WFL_FILENAME (type_or_wfl),
3487                         EXPR_WFL_LINENO (type_or_wfl),
3488                         EXPR_WFL_COLNO (type_or_wfl));
3489 #endif
3490   /* Re-install the existing qualifications so that the type can be
3491      resolved properly. */
3492   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3493   return wfl;
3494 }
3495
3496 static void
3497 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3498 {
3499   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3500     parse_error_context (wfl, "Interface %qs repeated",
3501                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3502 }
3503
3504 /* Bulk of common class/interface checks. Return 1 if an error was
3505    encountered. TAG is 0 for a class, 1 for an interface.  */
3506
3507 static int
3508 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3509                                 tree qualified_name, tree decl, tree cl)
3510 {
3511   tree node;
3512   int sca = 0;                  /* Static class allowed */
3513   int icaf = 0;                 /* Inner class allowed flags */
3514   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3515
3516   if (!quiet_flag)
3517     fprintf (stderr, " %s%s %s",
3518              (CPC_INNER_P () ? "inner" : ""),
3519              (is_interface ? "interface" : "class"),
3520              IDENTIFIER_POINTER (qualified_name));
3521
3522   /* Scope of an interface/class type name:
3523        - Can't be imported by a single type import
3524        - Can't already exists in the package */
3525   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3526       && (node = find_name_in_single_imports (raw_name))
3527       && !CPC_INNER_P ())
3528     {
3529       parse_error_context
3530         (cl, "%s name %qs clashes with imported type %qs",
3531          (is_interface ? "Interface" : "Class"),
3532          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3533       return 1;
3534     }
3535   if (decl && CLASS_COMPLETE_P (decl))
3536     {
3537       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3538                                    qualified_name, decl, cl);
3539       return 1;
3540     }
3541
3542   if (check_inner_class_redefinition (raw_name, cl))
3543     return 1;
3544
3545   /* If public, file name should match class/interface name, except
3546      when dealing with an inner class */
3547   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3548     {
3549       const char *fname = input_filename;
3550       const char *f;
3551
3552       for (f = fname + strlen (fname);
3553            f != fname && ! IS_DIR_SEPARATOR (*f);
3554            f--)
3555         ;
3556       if (IS_DIR_SEPARATOR (*f))
3557         f++;
3558       if (strncmp (IDENTIFIER_POINTER (raw_name),
3559                    f , IDENTIFIER_LENGTH (raw_name)) ||
3560           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3561         parse_error_context
3562           (cl, "Public %s %qs must be defined in a file called %<%s.java%>",
3563                              (is_interface ? "interface" : "class"),
3564                              IDENTIFIER_POINTER (qualified_name),
3565                              IDENTIFIER_POINTER (raw_name));
3566     }
3567
3568   /* Static classes can be declared only in top level classes. Note:
3569      once static, a inner class is a top level class. */
3570   if (flags & ACC_STATIC)
3571     {
3572       /* Catch the specific error of declaring an class inner class
3573          with no toplevel enclosing class. Prevent check_modifiers from
3574          complaining a second time */
3575       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3576         {
3577           parse_error_context (cl, "Inner class %qs can't be static. Static classes can only occur in interfaces and top-level classes",
3578                                IDENTIFIER_POINTER (qualified_name));
3579           sca = ACC_STATIC;
3580         }
3581       /* Else, in the context of a top-level class declaration, let
3582          `check_modifiers' do its job, otherwise, give it a go */
3583       else
3584         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3585     }
3586
3587   /* Inner classes can be declared private or protected
3588      within their enclosing classes. */
3589   if (CPC_INNER_P ())
3590     {
3591       /* A class which is local to a block can't be public, private,
3592          protected or static. But it is created final, so allow this
3593          one. */
3594       if (current_function_decl)
3595         icaf = sca = uaaf = ACC_FINAL;
3596       else
3597         {
3598           check_modifiers_consistency (flags);
3599           icaf = ACC_PROTECTED;
3600           if (! CLASS_INTERFACE (GET_CPC ()))
3601             icaf |= ACC_PRIVATE;
3602         }
3603     }
3604
3605   if (is_interface)
3606     {
3607       if (CPC_INNER_P ())
3608         uaaf = INTERFACE_INNER_MODIFIERS;
3609       else
3610         uaaf = INTERFACE_MODIFIERS;
3611
3612       check_modifiers ("Illegal modifier %qs for interface declaration",
3613                        flags, uaaf);
3614     }
3615   else
3616     check_modifiers ((current_function_decl ?
3617                       "Illegal modifier %qs for local class declaration" :
3618                       "Illegal modifier %qs for class declaration"),
3619                      flags, uaaf|sca|icaf);
3620   return 0;
3621 }
3622
3623 /* Construct a nested class name.  If the final component starts with
3624    a digit, return true.  Otherwise return false.  */
3625 static int
3626 make_nested_class_name (tree cpc_list)
3627 {
3628   tree name;
3629
3630   if (!cpc_list)
3631     return 0;
3632
3633   make_nested_class_name (TREE_CHAIN (cpc_list));
3634
3635   /* Pick the qualified name when dealing with the first upmost
3636      enclosing class */
3637   name = (TREE_CHAIN (cpc_list)
3638           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3639   obstack_grow (&temporary_obstack,
3640                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3641   obstack_1grow (&temporary_obstack, '$');
3642
3643   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3644 }
3645
3646 /* Can't redefine a class already defined in an earlier scope. */
3647
3648 static int
3649 check_inner_class_redefinition (tree raw_name, tree cl)
3650 {
3651   tree scope_list;
3652
3653   for (scope_list = GET_CPC_LIST (); scope_list;
3654        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3655     if (raw_name == GET_CPC_UN_NODE (scope_list))
3656       {
3657         parse_error_context
3658           (cl, "The class name %qs is already defined in this scope. An inner class may not have the same simple name as any of its enclosing classes",
3659            IDENTIFIER_POINTER (raw_name));
3660         return 1;
3661       }
3662   return 0;
3663 }
3664
3665 /* Tries to find a decl for CLASS_TYPE within ENCLOSING. If we fail,
3666    we remember ENCLOSING and SUPER.  */
3667
3668 static tree
3669 resolve_inner_class (htab_t circularity_hash, tree cl, tree *enclosing,
3670                      tree *super, tree class_type)
3671 {
3672   tree local_enclosing = *enclosing;
3673   tree local_super = NULL_TREE;
3674
3675   while (local_enclosing)
3676     {
3677       tree intermediate, decl;
3678
3679       *htab_find_slot (circularity_hash, local_enclosing, INSERT) =
3680         local_enclosing;
3681
3682       if ((decl = find_as_inner_class (local_enclosing, class_type, cl)))
3683         return decl;
3684
3685       intermediate = local_enclosing;
3686       /* Explore enclosing contexts. */
3687       while (INNER_CLASS_DECL_P (intermediate))
3688         {
3689           intermediate = DECL_CONTEXT (intermediate);
3690           if ((decl = find_as_inner_class (intermediate, class_type, cl)))
3691             return decl;
3692         }
3693
3694       /* Now go to the upper classes, bail out if necessary.  We will
3695          analyze the returned SUPER and act accordingly (see
3696          do_resolve_class).  */
3697       if (JPRIMITIVE_TYPE_P (TREE_TYPE (local_enclosing))
3698           || TREE_TYPE (local_enclosing) == void_type_node)
3699         {
3700           parse_error_context (cl, "Qualifier must be a reference");
3701           local_enclosing = NULL_TREE;
3702           break;
3703         }
3704       local_super = CLASSTYPE_SUPER (TREE_TYPE (local_enclosing));
3705       if (!local_super || local_super == object_type_node)
3706         break;
3707
3708       if (TREE_CODE (local_super) == POINTER_TYPE)
3709         local_super = do_resolve_class (NULL, local_super, NULL, NULL);
3710       else
3711         local_super = TYPE_NAME (local_super);
3712
3713       /* We may not have checked for circular inheritance yet, so do so
3714          here to prevent an infinite loop. */
3715       if (htab_find (circularity_hash, local_super) != NULL)
3716         {
3717           if (!cl)
3718             cl = lookup_cl (local_enclosing);
3719
3720           parse_error_context
3721             (cl, "Cyclic inheritance involving %s",
3722              IDENTIFIER_POINTER (DECL_NAME (local_enclosing)));
3723           local_enclosing = NULL_TREE;
3724         }
3725       else
3726         local_enclosing = local_super;
3727     }
3728
3729   /* We failed. Return LOCAL_SUPER and LOCAL_ENCLOSING. */
3730   *super = local_super;
3731   *enclosing = local_enclosing;
3732
3733   return NULL_TREE;
3734 }
3735
3736 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3737    qualified. */
3738
3739 static tree
3740 find_as_inner_class (tree enclosing, tree name, tree cl)
3741 {
3742   tree qual, to_return;
3743   if (!enclosing)
3744     return NULL_TREE;
3745
3746   name = TYPE_NAME (name);
3747
3748   /* First search: within the scope of `enclosing', search for name */
3749   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3750     qual = EXPR_WFL_QUALIFICATION (cl);
3751   else if (cl)
3752     qual = build_tree_list (cl, NULL_TREE);
3753   else
3754     qual = build_tree_list (build_unknown_wfl (name), NULL_TREE);
3755
3756   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3757     return to_return;
3758
3759   /* We're dealing with a qualified name. Try to resolve thing until
3760      we get something that is an enclosing class. */
3761   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3762     {
3763       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3764
3765       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3766            qual = TREE_CHAIN (qual))
3767         {
3768           acc = merge_qualified_name (acc,
3769                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3770           BUILD_PTR_FROM_NAME (ptr, acc);
3771           decl = do_resolve_class (NULL_TREE, ptr, NULL_TREE, cl);
3772         }
3773
3774       /* A NULL qual and a decl means that the search ended
3775          successfully?!? We have to do something then. FIXME */
3776
3777       if (decl)
3778         enclosing = decl;
3779       else
3780         qual = EXPR_WFL_QUALIFICATION (cl);
3781     }
3782   /* Otherwise, create a qual for the other part of the resolution. */
3783   else
3784     qual = build_tree_list (build_unknown_wfl (name), NULL_TREE);
3785
3786   return find_as_inner_class_do (qual, enclosing);
3787 }
3788
3789 /* We go inside the list of sub classes and try to find a way
3790    through. */
3791
3792 static tree
3793 find_as_inner_class_do (tree qual, tree enclosing)
3794 {
3795   if (!qual)
3796     return NULL_TREE;
3797
3798   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3799     {
3800       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3801       tree next_enclosing = NULL_TREE;
3802       tree inner_list;
3803
3804       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3805            inner_list; inner_list = TREE_CHAIN (inner_list))
3806         {
3807           if (TREE_VALUE (inner_list) == name_to_match)
3808             {
3809               next_enclosing = TREE_PURPOSE (inner_list);
3810               break;
3811             }
3812         }
3813       enclosing = next_enclosing;
3814     }
3815
3816   return (!qual && enclosing ? enclosing : NULL_TREE);
3817 }
3818
3819 static void
3820 link_nested_class_to_enclosing (void)
3821 {
3822   if (GET_ENCLOSING_CPC ())
3823     {
3824       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3825       DECL_INNER_CLASS_LIST (enclosing) =
3826         tree_cons (GET_CPC (), GET_CPC_UN (),
3827                    DECL_INNER_CLASS_LIST (enclosing));
3828     }
3829 }
3830
3831 static tree
3832 maybe_make_nested_class_name (tree name)
3833 {
3834   tree id = NULL_TREE;
3835
3836   if (CPC_INNER_P ())
3837     {
3838       /* If we're in a function, we must append a number to create the
3839          nested class name.  However, we don't do this if the class we
3840          are constructing is anonymous, because in that case we'll
3841          already have a number as the class name.  */
3842       if (! make_nested_class_name (GET_CPC_LIST ())
3843           && current_function_decl != NULL_TREE
3844           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3845         {
3846           char buf[10];
3847           sprintf (buf, "%d", anonymous_class_counter);
3848           ++anonymous_class_counter;
3849           obstack_grow (&temporary_obstack, buf, strlen (buf));
3850           obstack_1grow (&temporary_obstack, '$');
3851         }
3852       obstack_grow0 (&temporary_obstack,
3853                      IDENTIFIER_POINTER (name),
3854                      IDENTIFIER_LENGTH (name));
3855       id = get_identifier (obstack_finish (&temporary_obstack));
3856       if (ctxp->package)
3857         QUALIFIED_P (id) = 1;
3858     }
3859   return id;
3860 }
3861
3862 /* If DECL is NULL, create and push a new DECL, record the current
3863    line CL and do other maintenance things.  */
3864
3865 static tree
3866 maybe_create_class_interface_decl (tree decl, tree raw_name,
3867                                    tree qualified_name, tree cl)
3868 {
3869   if (!decl)
3870     decl = push_class (make_class (), qualified_name);
3871
3872   /* Take care of the file and line business */
3873 #ifdef USE_MAPPED_LOCATION
3874   DECL_SOURCE_LOCATION (decl) = EXPR_LOCATION (cl);
3875 #else
3876   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3877   DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3878 #endif
3879   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3880   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3881 #ifdef USE_MAPPED_LOCATION
3882   {
3883     tree tmp = maybe_get_identifier (EXPR_FILENAME (cl));
3884     CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3885       tmp && IS_A_COMMAND_LINE_FILENAME_P (tmp);
3886   }
3887 #else
3888   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3889     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3890 #endif
3891
3892   PUSH_CPC (decl, raw_name);
3893   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3894
3895   /* Link the declaration to the already seen ones */
3896   TREE_CHAIN (decl) = ctxp->class_list;
3897   ctxp->class_list = decl;
3898
3899   /* Create a new nodes in the global lists */
3900   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3901   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3902
3903   /* Install a new dependency list element */
3904   create_jdep_list (ctxp);
3905
3906   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3907                           IDENTIFIER_POINTER (qualified_name)));
3908   return decl;
3909 }
3910
3911 static void
3912 add_superinterfaces (tree decl, tree interface_list)
3913 {
3914   tree node;
3915   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3916      takes care of ensuring that:
3917        - This is an accessible interface type,
3918        - Circularity detection.
3919    parser_add_interface is then called. If present but not defined,
3920    the check operation is delayed until the super interface gets
3921    defined.  */
3922   for (node = interface_list; node; node = TREE_CHAIN (node))
3923     {
3924       tree current = TREE_PURPOSE (node);
3925       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3926       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3927         {
3928           if (!parser_check_super_interface (idecl, decl, current))
3929             parser_add_interface (decl, idecl, current);
3930         }
3931       else
3932         register_incomplete_type (JDEP_INTERFACE,
3933                                   current, decl, NULL_TREE);
3934     }
3935 }
3936
3937 /* Create an interface in pass1 and return its decl. Return the
3938    interface's decl in pass 2.  */
3939
3940 static tree
3941 create_interface (int flags, tree id, tree super)
3942 {
3943   tree raw_name = EXPR_WFL_NODE (id);
3944   tree q_name = parser_qualified_classname (raw_name);
3945   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3946
3947   /* Certain syntax errors are making SUPER be like ID. Avoid this
3948      case. */
3949   if (ctxp->class_err && id == super)
3950     super = NULL;
3951
3952   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3953
3954   /* Basic checks: scope, redefinition, modifiers */
3955   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3956     {
3957       PUSH_ERROR ();
3958       return NULL_TREE;
3959     }
3960
3961   /* Suspend the current parsing context if we're parsing an inner
3962      interface */
3963   if (CPC_INNER_P ())
3964     {
3965       java_parser_context_suspend ();
3966       /* Interface members are public. */
3967       if (CLASS_INTERFACE (GET_CPC ()))
3968         flags |= ACC_PUBLIC;
3969     }
3970
3971   /* Push a new context for (static) initialized upon declaration fields */
3972   java_parser_context_push_initialized_field ();
3973
3974   /* Interface modifiers check
3975        - public/abstract allowed (already done at that point)
3976        - abstract is obsolete (comes first, it's a warning, or should be)
3977        - Can't use twice the same (checked in the modifier rule) */
3978   if ((flags & ACC_ABSTRACT) && flag_redundant)
3979     parse_warning_context
3980       (MODIFIER_WFL (ABSTRACT_TK),
3981        "Redundant use of %<abstract%> modifier. Interface %qs is implicitly abstract", IDENTIFIER_POINTER (raw_name));
3982
3983   /* Create a new decl if DECL is NULL, otherwise fix it */
3984   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
3985
3986   /* Interfaces are always abstract. */
3987   flags |= ACC_ABSTRACT;
3988
3989   /* Inner interfaces are always static.  */
3990   if (INNER_CLASS_DECL_P (decl))
3991     flags |= ACC_STATIC;
3992
3993   /* Set super info and mark the class a complete */
3994   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
3995                   object_type_node, ctxp->interface_number);
3996   ctxp->interface_number = 0;
3997   CLASS_COMPLETE_P (decl) = 1;
3998   add_superinterfaces (decl, super);
3999
4000   /* Eventually sets the @deprecated tag flag */
4001   CHECK_DEPRECATED (decl);
4002
4003   return decl;
4004 }
4005
4006 /* Patch anonymous class CLASS, by either extending or implementing
4007    DEP.  */
4008
4009 static void
4010 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
4011 {
4012   tree class = TREE_TYPE (class_decl);
4013   tree type =  TREE_TYPE (type_decl);
4014   tree binfo = TYPE_BINFO (class);
4015
4016   /* If it's an interface, implement it */
4017   if (CLASS_INTERFACE (type_decl))
4018     {
4019       if (parser_check_super_interface (type_decl, class_decl, wfl))
4020         return;
4021
4022       if (!VEC_space (tree, BINFO_BASE_BINFOS (binfo), 1))
4023         {
4024            /* Extend the binfo - by reallocating and copying it. */
4025           tree new_binfo;
4026           tree base_binfo;
4027           int i;
4028
4029           new_binfo = make_tree_binfo ((BINFO_N_BASE_BINFOS (binfo) + 1) * 2);
4030           for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4031             BINFO_BASE_APPEND (new_binfo, base_binfo);
4032           CLASS_HAS_SUPER_FLAG (new_binfo) = CLASS_HAS_SUPER_FLAG (binfo);
4033           BINFO_VTABLE (new_binfo) = BINFO_VTABLE (binfo);
4034           TYPE_BINFO (class) = new_binfo;
4035         }
4036
4037       /* And add the interface */
4038       parser_add_interface (class_decl, type_decl, wfl);
4039     }
4040   /* Otherwise, it's a type we want to extend */
4041   else
4042     {
4043       if (parser_check_super (type_decl, class_decl, wfl))
4044         return;
4045       BINFO_TYPE (BINFO_BASE_BINFO (binfo, 0)) = type;
4046     }
4047 }
4048
4049 /* Create an anonymous class which extends/implements TYPE_NAME, and return
4050    its decl.  */
4051
4052 static tree
4053 create_anonymous_class (tree type_name)
4054 {
4055   char buffer [80];
4056   tree super = NULL_TREE, itf = NULL_TREE;
4057   tree id, type_decl, class;
4058
4059   /* The unqualified name of the anonymous class. It's just a number. */
4060   sprintf (buffer, "%d", anonymous_class_counter++);
4061   id = build_wfl_node (get_identifier (buffer));
4062   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL (type_name);
4063
4064   /* We know about the type to extend/implement. We go ahead */
4065   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
4066     {
4067       /* Create a class which either implements on extends the designated
4068          class. The class bears an inaccessible name. */
4069       if (CLASS_INTERFACE (type_decl))
4070         {
4071           /* It's OK to modify it here. It's been already used and
4072              shouldn't be reused */
4073           ctxp->interface_number = 1;
4074           /* Interfaces should presented as a list of WFLs */
4075           itf = build_tree_list (type_name, NULL_TREE);
4076         }
4077       else
4078         super = type_name;
4079     }
4080
4081   class = create_class (ACC_FINAL, id, super, itf);
4082
4083   /* We didn't know anything about the stuff. We register a dependence. */
4084   if (!type_decl)
4085     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
4086
4087   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
4088   return class;
4089 }
4090
4091 /* Create a class in pass1 and return its decl. Return class
4092    interface's decl in pass 2.  */
4093
4094 static tree
4095 create_class (int flags, tree id, tree super, tree interfaces)
4096 {
4097   tree raw_name = EXPR_WFL_NODE (id);
4098   tree class_id, decl;
4099   tree super_decl_type;
4100
4101   /* Certain syntax errors are making SUPER be like ID. Avoid this
4102      case. */
4103   if (ctxp->class_err && id == super)
4104     super = NULL;
4105
4106   class_id = parser_qualified_classname (raw_name);
4107   decl = IDENTIFIER_CLASS_VALUE (class_id);
4108   EXPR_WFL_NODE (id) = class_id;
4109
4110   /* Basic check: scope, redefinition, modifiers */
4111   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
4112     {
4113       PUSH_ERROR ();
4114       return NULL_TREE;
4115     }
4116
4117   /* Suspend the current parsing context if we're parsing an inner
4118      class or an anonymous class. */
4119   if (CPC_INNER_P ())
4120     {
4121       java_parser_context_suspend ();
4122       /* Interface members are public. */
4123       if (CLASS_INTERFACE (GET_CPC ()))
4124         flags |= ACC_PUBLIC;
4125     }
4126
4127   /* Push a new context for (static) initialized upon declaration fields */
4128   java_parser_context_push_initialized_field ();
4129
4130   /* Class modifier check:
4131        - Allowed modifier (already done at that point)
4132        - abstract AND final forbidden
4133        - Public classes defined in the correct file */
4134   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
4135     parse_error_context
4136       (id, "Class %qs can't be declared both abstract and final",
4137        IDENTIFIER_POINTER (raw_name));
4138
4139   /* Create a new decl if DECL is NULL, otherwise fix it */
4140   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
4141
4142   /* If SUPER exists, use it, otherwise use Object */
4143   if (super)
4144     {
4145       /* java.lang.Object can't extend anything.  */
4146       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
4147         {
4148           parse_error_context (id, "%<java.lang.Object%> can't extend anything");
4149           return NULL_TREE;
4150         }
4151
4152       super_decl_type =
4153         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4154     }
4155   else if (TREE_TYPE (decl) != object_type_node)
4156     super_decl_type = object_type_node;
4157   /* We're defining java.lang.Object */
4158   else
4159     super_decl_type = NULL_TREE;
4160
4161   /* A class nested in an interface is implicitly static. */
4162   if (INNER_CLASS_DECL_P (decl)
4163       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4164     {
4165       flags |= ACC_STATIC;
4166     }
4167
4168   /* Set super info and mark the class as complete. */
4169   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4170                   ctxp->interface_number);
4171   ctxp->interface_number = 0;
4172   CLASS_COMPLETE_P (decl) = 1;
4173   add_superinterfaces (decl, interfaces);
4174
4175   /* TYPE_VFIELD' is a compiler-generated field used to point to
4176      virtual function tables.  In gcj, every class has a common base
4177      virtual function table in java.lang.object.  */
4178   TYPE_VFIELD (TREE_TYPE (decl)) = TYPE_VFIELD (object_type_node);
4179
4180   /* Add the private this$<n> field, Replicate final locals still in
4181      scope as private final fields mangled like val$<local_name>.
4182      This does not occur for top level (static) inner classes. */
4183   if (PURE_INNER_CLASS_DECL_P (decl))
4184     add_inner_class_fields (decl, current_function_decl);
4185
4186   /* Eventually sets the @deprecated tag flag */
4187   CHECK_DEPRECATED (decl);
4188
4189   /* Reset the anonymous class counter when declaring non inner classes */
4190   if (!INNER_CLASS_DECL_P (decl))
4191     anonymous_class_counter = 1;
4192
4193   return decl;
4194 }
4195
4196 /* End a class declaration: register the statements used to create
4197    finit$ and <clinit>, pop the current class and resume the prior
4198    parser context if necessary.  */
4199
4200 static void
4201 end_class_declaration (int resume)
4202 {
4203   /* If an error occurred, context weren't pushed and won't need to be
4204      popped by a resume. */
4205   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4206
4207   if (GET_CPC () != error_mark_node)
4208     dump_java_tree (TDI_class, GET_CPC ());
4209
4210   java_parser_context_pop_initialized_field ();
4211   POP_CPC ();
4212   if (resume && no_error_occurred)
4213     java_parser_context_resume ();
4214
4215   /* We're ending a class declaration, this is a good time to reset
4216      the interface cout. Note that might have been already done in
4217      create_interface, but if at that time an inner class was being
4218      dealt with, the interface count was reset in a context created
4219      for the sake of handling inner classes declaration. */
4220   ctxp->interface_number = 0;
4221 }
4222
4223 static void
4224 add_inner_class_fields (tree class_decl, tree fct_decl)
4225 {
4226   tree block, marker, f;
4227
4228   f = add_field (TREE_TYPE (class_decl),
4229                  build_current_thisn (TREE_TYPE (class_decl)),
4230                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4231                  ACC_PRIVATE);
4232   FIELD_THISN (f) = 1;
4233
4234   if (!fct_decl)
4235     return;
4236
4237   for (block = GET_CURRENT_BLOCK (fct_decl);
4238        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4239     {
4240       tree decl;
4241       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4242         {
4243           tree name, pname;
4244           tree wfl, init, list;
4245
4246           /* Avoid non final arguments. */
4247           if (!LOCAL_FINAL_P (decl))
4248             continue;
4249
4250           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4251           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4252           wfl = build_wfl_node (name);
4253           init = build_wfl_node (pname);
4254           /* Build an initialization for the field: it will be
4255              initialized by a parameter added to finit$, bearing a
4256              mangled name of the field itself (param$<n>.) The
4257              parameter is provided to finit$ by the constructor
4258              invoking it (hence the constructor will also feature a
4259              hidden parameter, set to the value of the outer context
4260              local at the time the inner class is created.)
4261
4262              Note: we take into account all possible locals that can
4263              be accessed by the inner class. It's actually not trivial
4264              to minimize these aliases down to the ones really
4265              used. One way to do that would be to expand all regular
4266              methods first, then finit$ to get a picture of what's
4267              used.  It works with the exception that we would have to
4268              go back on all constructor invoked in regular methods to
4269              have their invocation reworked (to include the right amount
4270              of alias initializer parameters.)
4271
4272              The only real way around, I think, is a first pass to
4273              identify locals really used in the inner class. We leave
4274              the flag FIELD_LOCAL_ALIAS_USED around for that future
4275              use.
4276
4277              On the other hand, it only affect local inner classes,
4278              whose constructors (and finit$ call) will be featuring
4279              unnecessary arguments. It's easy for a developer to keep
4280              this number of parameter down by using the `final'
4281              keyword only when necessary. For the time being, we can
4282              issue a warning on unnecessary finals. FIXME */
4283           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4284                                    wfl, init);
4285
4286           /* Register the field. The TREE_LIST holding the part
4287              initialized/initializer will be marked ARG_FINAL_P so
4288              that the created field can be marked
4289              FIELD_LOCAL_ALIAS. */
4290           list = build_tree_list (wfl, init);
4291           ARG_FINAL_P (list) = 1;
4292           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4293         }
4294     }
4295
4296   if (!CPC_INITIALIZER_STMT (ctxp))
4297     return;
4298
4299   /* If we ever registered an alias field, insert and marker to
4300      remember where the list ends. The second part of the list (the one
4301      featuring initialized fields) so it can be later reversed to
4302      enforce 8.5. The marker will be removed during that operation. */
4303   marker = build_tree_list (NULL_TREE, NULL_TREE);
4304   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4305   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4306 }
4307
4308 /* Can't use lookup_field () since we don't want to load the class and
4309    can't set the CLASS_LOADED_P flag */
4310
4311 static tree
4312 find_field (tree class, tree name)
4313 {
4314   tree decl;
4315   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4316     {
4317       if (DECL_NAME (decl) == name)
4318         return decl;
4319     }
4320   return NULL_TREE;
4321 }
4322
4323 /* Wrap around lookup_field that doesn't potentially upset the value
4324    of CLASS */
4325
4326 static tree
4327 lookup_field_wrapper (tree class, tree name)
4328 {
4329   tree type = class;
4330   tree decl = NULL_TREE;
4331   java_parser_context_save_global ();
4332
4333   /* Last chance: if we're within the context of an inner class, we
4334      might be trying to access a local variable defined in an outer
4335      context. We try to look for it now. */
4336   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4337     {
4338       tree new_name;
4339       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4340       decl = lookup_field (&type, new_name);
4341       if (decl && decl != error_mark_node)
4342         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4343     }
4344   if (!decl || decl == error_mark_node)
4345     {
4346       type = class;
4347       decl = lookup_field (&type, name);
4348     }
4349
4350   /* If the field still hasn't been found, try the next enclosing context. */
4351   if (!decl && INNER_CLASS_TYPE_P (class))
4352     {
4353       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4354       decl = lookup_field_wrapper (outer_type, name);
4355     }
4356
4357   java_parser_context_restore_global ();
4358   return decl == error_mark_node ? NULL : decl;
4359 }
4360
4361 /* Find duplicate field within the same class declarations and report
4362    the error. Returns 1 if a duplicated field was found, 0
4363    otherwise.  */
4364
4365 static int
4366 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4367 {
4368   /* This might be modified to work with method decl as well */
4369   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4370   if (decl)
4371     {
4372       char *t1 = xstrdup (purify_type_name
4373                          ((TREE_CODE (new_type) == POINTER_TYPE
4374                            && TREE_TYPE (new_type) == NULL_TREE) ?
4375                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4376                           lang_printable_name (new_type, 1)));
4377       /* The type may not have been completed by the time we report
4378          the error */
4379       char *t2 = xstrdup (purify_type_name
4380                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4381                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4382                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4383                           lang_printable_name (TREE_TYPE (decl), 1)));
4384       parse_error_context
4385         (cl, "Duplicate variable declaration: %<%s %s%> was %<%s %s%> (%s:%d)",
4386          t1, IDENTIFIER_POINTER (new_field_name),
4387          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4388          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4389       free (t1);
4390       free (t2);
4391       return 1;
4392     }
4393   return 0;
4394 }
4395
4396 /* Field registration routine. If TYPE doesn't exist, field
4397    declarations are linked to the undefined TYPE dependency list, to
4398    be later resolved in java_complete_class () */
4399
4400 static void
4401 register_fields (int flags, tree type, tree variable_list)
4402 {
4403   tree current, saved_type;
4404   tree class_type = NULL_TREE;
4405   location_t saved_location = input_location;
4406   int must_chain = 0;
4407   tree wfl = NULL_TREE;
4408
4409   if (GET_CPC ())
4410     class_type = TREE_TYPE (GET_CPC ());
4411
4412   if (!class_type || class_type == error_mark_node)
4413     return;
4414
4415   /* If we're adding fields to interfaces, those fields are public,
4416      static, final */
4417   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4418     {
4419       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4420                                  flags, ACC_PUBLIC, "interface field(s)");
4421       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4422                                  flags, ACC_STATIC, "interface field(s)");
4423       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4424                                  flags, ACC_FINAL, "interface field(s)");
4425       check_modifiers ("Illegal interface member modifier %qs", flags,
4426                        INTERFACE_FIELD_MODIFIERS);
4427       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4428     }
4429
4430   /* Obtain a suitable type for resolution, if necessary */
4431   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4432
4433   /* If TYPE is fully resolved and we don't have a reference, make one */
4434   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4435
4436   for (current = variable_list, saved_type = type; current;
4437        current = TREE_CHAIN (current), type = saved_type)
4438     {
4439       tree real_type;
4440       tree field_decl;
4441       tree cl = TREE_PURPOSE (current);
4442       tree init = TREE_VALUE (current);
4443       tree current_name = EXPR_WFL_NODE (cl);
4444
4445       /* Can't declare non-final static fields in inner classes */
4446       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4447           && !(flags & ACC_FINAL))
4448         parse_error_context
4449           (cl, "Field %qs can't be static in inner class %qs unless it is final",
4450            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4451            lang_printable_name (class_type, 0));
4452
4453       /* Process NAME, as it may specify extra dimension(s) for it */
4454       type = build_array_from_name (type, wfl, current_name, &current_name);
4455
4456       /* Type adjustment. We may have just readjusted TYPE because
4457          the variable specified more dimensions. Make sure we have
4458          a reference if we can and don't have one already. Also
4459          change the name if we have an init. */
4460       if (type != saved_type)
4461         {
4462           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4463           if (init)
4464             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4465         }
4466
4467       real_type = GET_REAL_TYPE (type);
4468       /* Check for redeclarations */
4469       if (duplicate_declaration_error_p (current_name, real_type, cl))
4470         continue;
4471
4472       /* Set input_line to the line the field was found and create a
4473          declaration for it. Eventually sets the @deprecated tag flag. */
4474 #ifdef USE_MAPPED_LOCATION
4475       input_location = EXPR_LOCATION (cl);
4476 #else
4477       input_line = EXPR_WFL_LINENO (cl);
4478 #endif
4479       field_decl = add_field (class_type, current_name, real_type, flags);
4480       CHECK_DEPRECATED_NO_RESET (field_decl);
4481
4482       /* If the field denotes a final instance variable, then we
4483          allocate a LANG_DECL_SPECIFIC part to keep track of its
4484          initialization. We also mark whether the field was
4485          initialized upon its declaration. We don't do that if the
4486          created field is an alias to a final local. */
4487       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4488         {
4489           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4490           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4491         }
4492
4493       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4494          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4495          hide parameters to this inner class finit$ and
4496          constructors. It also means that the field isn't final per
4497          say. */
4498       if (ARG_FINAL_P (current))
4499         {
4500           FIELD_LOCAL_ALIAS (field_decl) = 1;
4501           FIELD_FINAL (field_decl) = 0;
4502         }
4503
4504       /* Check if we must chain. */
4505       if (must_chain)
4506         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4507
4508       /* If we have an initialization value tied to the field */
4509       if (init)
4510         {
4511           /* The field is declared static */
4512           if (flags & ACC_STATIC)
4513             {
4514               /* We include the field and its initialization part into
4515                  a list used to generate <clinit>. After <clinit> is
4516                  walked, field initializations will be processed and
4517                  fields initialized with known constants will be taken
4518                  out of <clinit> and have their DECL_INITIAL set
4519                  appropriately. */
4520               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4521               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4522               if (TREE_OPERAND (init, 1)
4523                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4524                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4525             }
4526           /* A non-static field declared with an immediate initialization is
4527              to be initialized in <init>, if any.  This field is remembered
4528              to be processed at the time of the generation of <init>. */
4529           else
4530             {
4531               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4532               SET_CPC_INITIALIZER_STMT (ctxp, init);
4533             }
4534           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4535           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4536         }
4537     }
4538
4539   CLEAR_DEPRECATED;
4540   input_location = saved_location;
4541 }
4542
4543 /* Generate finit$, using the list of initialized fields to populate
4544    its body. finit$'s parameter(s) list is adjusted to include the
4545    one(s) used to initialized the field(s) caching outer context
4546    local(s).  */
4547
4548 static tree
4549 generate_finit (tree class_type)
4550 {
4551   int count = 0;
4552   tree list = TYPE_FINIT_STMT_LIST (class_type);
4553   tree mdecl, current, parms;
4554
4555   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4556                                                   class_type, NULL_TREE,
4557                                                   &count);
4558   CRAFTED_PARAM_LIST_FIXUP (parms);
4559   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4560                                     finit_identifier_node, parms);
4561   fix_method_argument_names (parms, mdecl);
4562   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4563                        mdecl, NULL_TREE);
4564   DECL_FUNCTION_NAP (mdecl) = count;
4565   start_artificial_method_body (mdecl);
4566
4567   for (current = list; current; current = TREE_CHAIN (current))
4568     java_method_add_stmt (mdecl,
4569                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4570                                                 current));
4571   end_artificial_method_body (mdecl);
4572   return mdecl;
4573 }
4574
4575 /* Generate a function to run the instance initialization code. The
4576    private method is called `instinit$'. Unless we're dealing with an
4577    anonymous class, we determine whether all ctors of CLASS_TYPE
4578    declare a checked exception in their `throws' clause in order to
4579    see whether it's necessary to encapsulate the instance initializer
4580    statements in a try/catch/rethrow sequence.  */
4581
4582 static tree
4583 generate_instinit (tree class_type)
4584 {
4585   tree current;
4586   tree compound = NULL_TREE;
4587   tree parms = tree_cons (this_identifier_node,
4588                           build_pointer_type (class_type), end_params_node);
4589   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4590                                          void_type_node,
4591                                          instinit_identifier_node, parms);
4592
4593   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4594                        mdecl, NULL_TREE);
4595
4596   /* Gather all the statements in a compound */
4597   for (current = TYPE_II_STMT_LIST (class_type);
4598        current; current = TREE_CHAIN (current))
4599     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4600
4601   /* We need to encapsulate COMPOUND by a try/catch statement to
4602      rethrow exceptions that might occur in the instance initializer.
4603      We do that only if all ctors of CLASS_TYPE are set to catch a
4604      checked exception. This doesn't apply to anonymous classes (since
4605      they don't have declared ctors.) */
4606   if (!ANONYMOUS_CLASS_P (class_type) &&
4607       ctors_unchecked_throws_clause_p (class_type))
4608     {
4609       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4610                                              build1 (THROW_EXPR, NULL_TREE,
4611                                                      build_wfl_node (wpv_id)));
4612       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4613                                                       exception_type_node);
4614     }
4615
4616   start_artificial_method_body (mdecl);
4617   java_method_add_stmt (mdecl, compound);
4618   end_artificial_method_body (mdecl);
4619
4620   return mdecl;
4621 }
4622
4623 /* FIXME */
4624 static tree
4625 build_instinit_invocation (tree class_type)
4626 {
4627   tree to_return = NULL_TREE;
4628
4629   if (TYPE_II_STMT_LIST (class_type))
4630     {
4631       tree parm = build_tree_list (NULL_TREE,
4632                                    build_wfl_node (this_identifier_node));
4633       to_return =
4634         build_method_invocation (build_wfl_node (instinit_identifier_node),
4635                                  parm);
4636     }
4637   return to_return;
4638 }
4639
4640 /* Shared across method_declarator and method_header to remember the
4641    patch stage that was reached during the declaration of the method.
4642    A method DECL is built differently is there is no patch
4643    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4644    pending on the currently defined method.  */
4645
4646 static int patch_stage;
4647
4648 /* Check the method declaration and add the method to its current
4649    class.  If the argument list is known to contain incomplete types,
4650    the method is partially added and the registration will be resume
4651    once the method arguments resolved. If TYPE is NULL, we're dealing
4652    with a constructor.  */
4653
4654 static tree
4655 method_header (int flags, tree type, tree mdecl, tree throws)
4656 {
4657   tree type_wfl = NULL_TREE;
4658   tree meth_name = NULL_TREE;
4659   tree current, orig_arg, this_class = NULL;
4660   tree id, meth;
4661   location_t saved_location;
4662   int constructor_ok = 0, must_chain;
4663   int count;
4664
4665   if (mdecl == error_mark_node)
4666     return error_mark_node;
4667   meth = TREE_VALUE (mdecl);
4668   id = TREE_PURPOSE (mdecl);
4669
4670   check_modifiers_consistency (flags);
4671
4672   if (GET_CPC ())
4673     this_class = TREE_TYPE (GET_CPC ());
4674
4675   if (!this_class || this_class == error_mark_node)
4676     return NULL_TREE;
4677
4678   /* There are some forbidden modifiers for an abstract method and its
4679      class must be abstract as well.  */
4680   if (type && (flags & ACC_ABSTRACT))
4681     {
4682       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4683       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4684       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4685       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4686       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4687       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4688       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4689           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4690         parse_error_context
4691           (id,
4692            "Class %qs must be declared abstract to define abstract method %qs",
4693            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4694            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4695     }
4696
4697   /* A native method can't be strictfp.  */
4698   if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4699     parse_error_context (id, "native method %qs can't be strictfp",
4700                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4701   /* No such thing as a transient or volatile method.  */
4702   if ((flags & ACC_TRANSIENT))
4703     parse_error_context (id, "method %qs can't be transient",
4704                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4705   if ((flags & ACC_VOLATILE))
4706     parse_error_context (id, "method %qs can't be volatile",
4707                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4708
4709   /* Things to be checked when declaring a constructor */
4710   if (!type)
4711     {
4712       int ec = java_error_count;
4713       /* 8.6: Constructor declarations: we might be trying to define a
4714          method without specifying a return type. */
4715       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4716         parse_error_context
4717           (id, "Invalid method declaration, return type required");
4718       /* 8.6.3: Constructor modifiers */
4719       else
4720         {
4721           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4722           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4723           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4724           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4725           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4726           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4727         }
4728       /* If we found error here, we don't consider it's OK to tread
4729          the method definition as a constructor, for the rest of this
4730          function */
4731       if (ec == java_error_count)
4732         constructor_ok = 1;
4733     }
4734
4735   /* Method declared within the scope of an interface are implicitly
4736      abstract and public. Conflicts with other erroneously provided
4737      modifiers are checked right after. */
4738
4739   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4740     {
4741       /* If FLAGS isn't set because of a modifier, turn the
4742          corresponding modifier WFL to NULL so we issue a warning on
4743          the obsolete use of the modifier */
4744       if (!(flags & ACC_PUBLIC))
4745         MODIFIER_WFL (PUBLIC_TK) = NULL;
4746       if (!(flags & ACC_ABSTRACT))
4747         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4748       flags |= ACC_PUBLIC;
4749       flags |= ACC_ABSTRACT;
4750     }
4751
4752   /* Inner class can't declare static methods */
4753   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4754     {
4755       parse_error_context
4756         (id, "Method %qs can't be static in inner class %qs. Only members of interfaces and top-level classes can be static",
4757          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4758          lang_printable_name (this_class, 0));
4759     }
4760
4761   /* Modifiers context reset moved up, so abstract method declaration
4762      modifiers can be later checked.  */
4763
4764   /* Set constructor returned type to void and method name to <init>,
4765      unless we found an error identifier the constructor (in which
4766      case we retain the original name) */
4767   if (!type)
4768     {
4769       type = void_type_node;
4770       if (constructor_ok)
4771         meth_name = init_identifier_node;
4772     }
4773   else
4774     meth_name = EXPR_WFL_NODE (id);
4775
4776   /* Do the returned type resolution and registration if necessary */
4777   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4778
4779   if (meth_name)
4780     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4781   EXPR_WFL_NODE (id) = meth_name;
4782   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4783
4784   if (must_chain)
4785     {
4786       patch_stage = JDEP_METHOD_RETURN;
4787       register_incomplete_type (patch_stage, type_wfl, id, type);
4788       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4789     }
4790   else
4791     TREE_TYPE (meth) = type;
4792
4793   saved_location = input_location;
4794   /* When defining an abstract or interface method, the curly
4795      bracket at level 1 doesn't exist because there is no function
4796      body */
4797 #ifdef USE_MAPPED_LOCATION
4798   input_location = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4799                     EXPR_LOCATION (id));
4800 #else
4801   input_line = (ctxp->first_ccb_indent1 ? (int) ctxp->first_ccb_indent1 :
4802                 EXPR_WFL_LINENO (id));
4803 #endif
4804
4805   /* Remember the original argument list */
4806   orig_arg = TYPE_ARG_TYPES (meth);
4807
4808   if (patch_stage)              /* includes ret type and/or all args */
4809     {
4810       jdep *jdep;
4811       meth = add_method_1 (this_class, flags, meth_name, meth);
4812       /* Patch for the return type */
4813       if (patch_stage == JDEP_METHOD_RETURN)
4814         {
4815           jdep = CLASSD_LAST (ctxp->classd_list);
4816           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4817         }
4818       /* This is the stop JDEP. METH allows the function's signature
4819          to be computed. */
4820       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4821     }
4822   else
4823     meth = add_method (this_class, flags, meth_name,
4824                        build_java_signature (meth));
4825
4826   /* Remember final parameters */
4827   MARK_FINAL_PARMS (meth, orig_arg);
4828
4829   /* Fix the method argument list so we have the argument name
4830      information */
4831   fix_method_argument_names (orig_arg, meth);
4832
4833   /* Register the parameter number and re-install the current line
4834      number */
4835   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4836   input_location = saved_location;
4837
4838   /* Register exception specified by the `throws' keyword for
4839      resolution and set the method decl appropriate field to the list.
4840      Note: the grammar ensures that what we get here are class
4841      types. */
4842   if (throws)
4843     {
4844       throws = nreverse (throws);
4845       for (current = throws; current; current = TREE_CHAIN (current))
4846         {
4847           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4848                                     NULL_TREE, NULL_TREE);
4849           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4850             &TREE_VALUE (current);
4851         }
4852       DECL_FUNCTION_THROWS (meth) = throws;
4853     }
4854
4855   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4856     DECL_FUNCTION_WFL (meth) = id;
4857
4858   /* Set the flag if we correctly processed a constructor */
4859   if (constructor_ok)
4860     {
4861       DECL_CONSTRUCTOR_P (meth) = 1;
4862       /* Compute and store the number of artificial parameters declared
4863          for this constructor */
4864       for (count = 0, current = TYPE_FIELDS (this_class); current;
4865            current = TREE_CHAIN (current))
4866         if (FIELD_LOCAL_ALIAS (current))
4867           count++;
4868       DECL_FUNCTION_NAP (meth) = count;
4869     }
4870
4871   /* Eventually set the @deprecated tag flag */
4872   CHECK_DEPRECATED (meth);
4873
4874   return meth;
4875 }
4876
4877 static void
4878 fix_method_argument_names (tree orig_arg, tree meth)
4879 {
4880   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4881   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4882     {
4883       TREE_PURPOSE (arg) = this_identifier_node;
4884       arg = TREE_CHAIN (arg);
4885     }
4886   while (orig_arg != end_params_node)
4887     {
4888       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4889       orig_arg = TREE_CHAIN (orig_arg);
4890       arg = TREE_CHAIN (arg);
4891     }
4892 }
4893
4894 /* Complete the method declaration with METHOD_BODY.  */
4895
4896 static void
4897 finish_method_declaration (tree method_body)
4898 {
4899   int flags;
4900
4901   if (!current_function_decl)
4902     return;
4903
4904   flags = get_access_flags_from_decl (current_function_decl);
4905
4906   /* 8.4.5 Method Body */
4907   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4908     {
4909       tree name = DECL_NAME (current_function_decl);
4910       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4911                            "%s method %qs can't have a body defined",
4912                            (METHOD_NATIVE (current_function_decl) ?
4913                             "Native" : "Abstract"),
4914                            IDENTIFIER_POINTER (name));
4915       method_body = NULL_TREE;
4916     }
4917   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4918     {
4919       tree name = DECL_NAME (current_function_decl);
4920       parse_error_context
4921         (DECL_FUNCTION_WFL (current_function_decl),
4922          "Non native and non abstract method %qs must have a body defined",
4923          IDENTIFIER_POINTER (name));
4924       method_body = NULL_TREE;
4925     }
4926
4927   if (flag_emit_class_files && method_body
4928       && TREE_CODE (method_body) == NOP_EXPR
4929       && TREE_TYPE (current_function_decl)
4930       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4931     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4932
4933   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4934   maybe_absorb_scoping_blocks ();
4935   /* Exit function's body */
4936   exit_block ();
4937   /* Merge last line of the function with first line, directly in the
4938      function decl. It will be used to emit correct debug info. */
4939   DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4940
4941   /* Since function's argument's list are shared, reset the
4942      ARG_FINAL_P parameter that might have been set on some of this
4943      function parameters. */
4944   UNMARK_FINAL_PARMS (current_function_decl);
4945
4946   /* So we don't have an irrelevant function declaration context for
4947      the next static block we'll see. */
4948   current_function_decl = NULL_TREE;
4949 }
4950
4951 /* Build a an error message for constructor circularity errors.  */
4952
4953 static char *
4954 constructor_circularity_msg (tree from, tree to)
4955 {
4956   static char string [4096];
4957   char *t = xstrdup (lang_printable_name (from, 2));
4958   sprintf (string, "'%s' invokes '%s'", t, lang_printable_name (to, 2));
4959   free (t);
4960   return string;
4961 }
4962
4963 /* Verify a circular call to METH. Return 1 if an error is found, 0
4964    otherwise.  */
4965
4966 static GTY(()) tree vcc_list;
4967 static int
4968 verify_constructor_circularity (tree meth, tree current)
4969 {
4970   tree c;
4971
4972   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4973     {
4974       if (TREE_VALUE (c) == meth)
4975         {
4976           char *t;
4977           if (vcc_list)
4978             {
4979               tree liste;
4980               vcc_list = nreverse (vcc_list);
4981               for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
4982                 {
4983                   parse_error_context
4984                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
4985                      constructor_circularity_msg
4986                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
4987                   java_error_count--;
4988                 }
4989             }
4990           t = xstrdup (lang_printable_name (meth, 2));
4991           parse_error_context (TREE_PURPOSE (c),
4992                                "%s: recursive invocation of constructor %qs",
4993                                constructor_circularity_msg (current, meth), t);
4994           free (t);
4995           vcc_list = NULL_TREE;
4996           return 1;
4997         }
4998     }
4999   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
5000     {
5001       vcc_list = tree_cons (c, current, vcc_list);
5002       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
5003         return 1;
5004       vcc_list = TREE_CHAIN (vcc_list);
5005     }
5006   return 0;
5007 }
5008
5009 /* Check modifiers that can be declared but exclusively */
5010
5011 static void
5012 check_modifiers_consistency (int flags)
5013 {
5014   int acc_count = 0;
5015   tree cl = NULL_TREE;
5016
5017   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
5018   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
5019   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
5020   if (acc_count > 1)
5021     parse_error_context
5022       (cl, "Inconsistent member declaration.  At most one of %<public%>, %<private%>, or %<protected%> may be specified");
5023
5024   acc_count = 0;
5025   cl = NULL_TREE;
5026   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
5027   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
5028   if (acc_count > 1)
5029     parse_error_context (cl,
5030                          "Inconsistent member declaration.  At most one of %<final%> or %<volatile%> may be specified");
5031 }
5032
5033 /* Check the methode header METH for abstract specifics features */
5034
5035 static void
5036 check_abstract_method_header (tree meth)
5037 {
5038   int flags = get_access_flags_from_decl (meth);
5039
5040   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
5041                               ACC_ABSTRACT, "abstract method",
5042                               IDENTIFIER_POINTER (DECL_NAME (meth)));
5043   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
5044                               ACC_PUBLIC, "abstract method",
5045                               IDENTIFIER_POINTER (DECL_NAME (meth)));
5046
5047   check_modifiers ("Illegal modifier %qs for interface method",
5048                   flags, INTERFACE_METHOD_MODIFIERS);
5049 }
5050
5051 /* Create a FUNCTION_TYPE node and start augmenting it with the
5052    declared function arguments. Arguments type that can't be resolved
5053    are left as they are, but the returned node is marked as containing
5054    incomplete types.  */
5055
5056 static tree
5057 method_declarator (tree id, tree list)
5058 {
5059   tree arg_types = NULL_TREE, current, node;
5060   tree meth = make_node (FUNCTION_TYPE);
5061   jdep *jdep;
5062
5063   patch_stage = JDEP_NO_PATCH;
5064
5065   if (GET_CPC () == error_mark_node)
5066     return error_mark_node;
5067
5068   /* If we're dealing with an inner class constructor, we hide the
5069      this$<n> decl in the name field of its parameter declaration.  We
5070      also might have to hide the outer context local alias
5071      initializers. Not done when the class is a toplevel class. */
5072   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
5073       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
5074     {
5075       tree aliases_list, type, thisn;
5076       /* First the aliases, linked to the regular parameters */
5077       aliases_list =
5078         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
5079                                                 TREE_TYPE (GET_CPC ()),
5080                                                 NULL_TREE, NULL);
5081       list = chainon (nreverse (aliases_list), list);
5082
5083       /* Then this$<n> */
5084       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
5085       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
5086       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
5087                         list);
5088     }
5089
5090   for (current = list; current; current = TREE_CHAIN (current))
5091     {
5092       int must_chain = 0;
5093       tree wfl_name = TREE_PURPOSE (current);
5094       tree type = TREE_VALUE (current);
5095       tree name = EXPR_WFL_NODE (wfl_name);
5096       tree already, arg_node;
5097       tree type_wfl = NULL_TREE;
5098       tree real_type;
5099
5100       /* Obtain a suitable type for resolution, if necessary */
5101       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
5102
5103       /* Process NAME, as it may specify extra dimension(s) for it */
5104       type = build_array_from_name (type, type_wfl, name, &name);
5105       EXPR_WFL_NODE (wfl_name) = name;
5106
5107       real_type = GET_REAL_TYPE (type);
5108       if (TREE_CODE (real_type) == RECORD_TYPE)
5109         {
5110           real_type = promote_type (real_type);
5111           if (TREE_CODE (type) == TREE_LIST)
5112             TREE_PURPOSE (type) = real_type;
5113         }
5114
5115       /* Check redefinition */
5116       for (already = arg_types; already; already = TREE_CHAIN (already))
5117         if (TREE_PURPOSE (already) == name)
5118           {
5119             parse_error_context
5120               (wfl_name, "Variable %qs is used more than once in the argument list of method %qs",
5121                IDENTIFIER_POINTER (name),
5122                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
5123             break;
5124           }
5125
5126       /* If we've an incomplete argument type, we know there is a location
5127          to patch when the type get resolved, later.  */
5128       jdep = NULL;
5129       if (must_chain)
5130         {
5131           patch_stage = JDEP_METHOD;
5132           type = register_incomplete_type (patch_stage,
5133                                            type_wfl, wfl_name, type);
5134           jdep = CLASSD_LAST (ctxp->classd_list);
5135           JDEP_MISC (jdep) = id;
5136         }
5137
5138       /* The argument node: a name and a (possibly) incomplete type.  */
5139       arg_node = build_tree_list (name, real_type);
5140       /* Remember arguments declared final. */
5141       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
5142
5143       if (jdep)
5144         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
5145       TREE_CHAIN (arg_node) = arg_types;
5146       arg_types = arg_node;
5147     }
5148   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
5149   node = build_tree_list (id, meth);
5150   return node;
5151 }
5152
5153 static int
5154 unresolved_type_p (tree wfl, tree *returned)
5155 {
5156   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5157     {
5158       if (returned)
5159         {
5160           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5161           if (decl && current_class && (decl == TYPE_NAME (current_class)))
5162             *returned = TREE_TYPE (decl);
5163           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5164             *returned = TREE_TYPE (GET_CPC ());
5165           else
5166             *returned = NULL_TREE;
5167         }
5168       return 1;
5169     }
5170   if (returned)
5171     *returned = wfl;
5172   return 0;
5173 }
5174
5175 /* From NAME, build a qualified identifier node using the
5176    qualification from the current package definition. */
5177
5178 static tree
5179 parser_qualified_classname (tree name)
5180 {
5181   tree nested_class_name;
5182
5183   if ((nested_class_name = maybe_make_nested_class_name (name)))
5184     return nested_class_name;
5185
5186   if (ctxp->package)
5187     return merge_qualified_name (ctxp->package, name);
5188   else
5189     return name;
5190 }
5191
5192 /* Called once the type a interface extends is resolved. Returns 0 if
5193    everything is OK.  */
5194
5195 static int
5196 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5197 {
5198   tree super_type = TREE_TYPE (super_decl);
5199
5200   /* Has to be an interface */
5201   if (!CLASS_INTERFACE (super_decl))
5202     {
5203       parse_error_context
5204         (this_wfl, "%s %qs can't implement/extend %s %qs",
5205          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5206           "Interface" : "Class"),
5207          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5208          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5209          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5210       return 1;
5211     }
5212
5213   /* Check top-level interface access. Inner classes are subject to member
5214      access rules (6.6.1). */
5215   if (! INNER_CLASS_P (super_type)
5216       && check_pkg_class_access (DECL_NAME (super_decl),
5217                                  NULL_TREE, true, this_decl))
5218     return 1;
5219
5220   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5221                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5222                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5223   return 0;
5224 }
5225
5226 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5227    0 if everything is OK.  */
5228
5229 static int
5230 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5231 {
5232   tree super_type = TREE_TYPE (super_decl);
5233
5234   /* SUPER should be a CLASS (neither an array nor an interface) */
5235   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5236     {
5237       parse_error_context
5238         (wfl, "Class %qs can't subclass %s %qs",
5239          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5240          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5241          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5242       return 1;
5243     }
5244
5245   if (CLASS_FINAL (TYPE_NAME (super_type)))
5246     {
5247       parse_error_context (wfl, "Can't subclass final classes: %s",
5248                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5249       return 1;
5250     }
5251
5252   /* Check top-level class scope. Inner classes are subject to member access
5253      rules (6.6.1). */
5254   if (! INNER_CLASS_P (super_type)
5255       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true, NULL_TREE)))
5256     return 1;
5257
5258   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5259                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5260                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5261   return 0;
5262 }
5263
5264 /* Create a new dependency list and link it (in a LIFO manner) to the
5265    CTXP list of type dependency list.  */
5266
5267 static void
5268 create_jdep_list (struct parser_ctxt *ctxp)
5269 {
5270   jdeplist *new = xmalloc (sizeof (jdeplist));
5271   new->first = new->last = NULL;
5272   new->next = ctxp->classd_list;
5273   ctxp->classd_list = new;
5274 }
5275
5276 static jdeplist *
5277 reverse_jdep_list (struct parser_ctxt *ctxp)
5278 {
5279   jdeplist *prev = NULL, *current, *next;
5280   for (current = ctxp->classd_list; current; current = next)
5281     {
5282       next = current->next;
5283       current->next = prev;
5284       prev = current;
5285     }
5286   return prev;
5287 }
5288
5289 /* Create a fake pointer based on the ID stored in
5290    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5291    registered again. */
5292
5293 static tree
5294 obtain_incomplete_type (tree type_name)
5295 {
5296   tree ptr = NULL_TREE, name;
5297
5298   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5299     name = EXPR_WFL_NODE (type_name);
5300   else if (INCOMPLETE_TYPE_P (type_name))
5301     name = TYPE_NAME (type_name);
5302   else
5303     abort ();
5304
5305   /* Workaround from build_pointer_type for incomplete types.  */
5306   BUILD_PTR_FROM_NAME (ptr, name);
5307   TYPE_MODE (ptr) = ptr_mode;
5308   layout_type (ptr);
5309
5310   return ptr;
5311 }
5312
5313 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5314    non NULL instead of computing a new fake type based on WFL. The new
5315    dependency is inserted in the current type dependency list, in FIFO
5316    manner.  */
5317
5318 static tree
5319 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5320 {
5321   jdep *new = xmalloc (sizeof (jdep));
5322
5323   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5324     ptr = obtain_incomplete_type (wfl);
5325
5326   JDEP_KIND (new) = kind;
5327   JDEP_DECL (new) = decl;
5328   JDEP_TO_RESOLVE (new) = ptr;
5329   JDEP_WFL (new) = wfl;
5330   JDEP_CHAIN (new) = NULL;
5331   JDEP_MISC (new) = NULL_TREE;
5332   /* For some dependencies, set the enclosing class of the current
5333      class to be the enclosing context */
5334   if ((kind == JDEP_INTERFACE || kind == JDEP_ANONYMOUS || kind == JDEP_SUPER)
5335       && GET_ENCLOSING_CPC ())
5336     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5337   else
5338     JDEP_ENCLOSING (new) = GET_CPC ();
5339   JDEP_GET_PATCH (new) = (tree *)NULL;
5340
5341   JDEP_INSERT (ctxp->classd_list, new);
5342
5343   return ptr;
5344 }
5345
5346 /* This checks for circular references with innerclasses. We start
5347    from SOURCE and should never reach TARGET. Extended/implemented
5348    types in SOURCE have their enclosing context checked not to reach
5349    TARGET. When the last enclosing context of SOURCE is reached, its
5350    extended/implemented types are also checked not to reach TARGET.
5351    In case of error, WFL of the offending type is returned; NULL_TREE
5352    otherwise.  */
5353
5354 static tree
5355 check_inner_circular_reference (tree source, tree target)
5356 {
5357   tree base_binfo;
5358   tree ctx, cl;
5359   int i;
5360
5361   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (source), i, base_binfo); i++)
5362     {
5363       tree su;
5364
5365       /* We can end up with a NULL_TREE or an incomplete type here if
5366          we encountered previous type resolution errors. It's safe to
5367          simply ignore these cases.  */
5368       su = BINFO_TYPE (base_binfo);
5369       if (INCOMPLETE_TYPE_P (su))
5370         continue;
5371
5372       if (inherits_from_p (su, target))
5373         return lookup_cl (TYPE_NAME (su));
5374
5375       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5376         {
5377           /* An enclosing context shouldn't be TARGET */
5378           if (ctx == TYPE_NAME (target))
5379             return lookup_cl (TYPE_NAME (su));
5380
5381           /* When we reach the enclosing last context, start a check
5382              on it, with the same target */
5383           if (! DECL_CONTEXT (ctx) &&
5384               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5385             return cl;
5386         }
5387     }
5388   return NULL_TREE;
5389 }
5390
5391 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5392    offending type if a circularity is detected. NULL_TREE is returned
5393    otherwise. TYPE can be an interface or a class.   */
5394
5395 static tree
5396 check_circular_reference (tree type)
5397 {
5398   tree base_binfo;
5399   int i;
5400
5401   if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type)))
5402     return NULL_TREE;
5403
5404   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5405     {
5406       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5407         return lookup_cl (TYPE_NAME (type));
5408       return NULL_TREE;
5409     }
5410
5411   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (type), i, base_binfo); i++)
5412     {
5413       if (BINFO_TYPE (base_binfo) != object_type_node
5414           && interface_of_p (type, BINFO_TYPE (base_binfo)))
5415         return lookup_cl (TYPE_NAME (BINFO_TYPE (base_binfo)));
5416     }
5417   return NULL_TREE;
5418 }
5419
5420 void
5421 java_check_circular_reference (void)
5422 {
5423   tree current;
5424   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5425     {
5426       tree type = TREE_TYPE (current);
5427       tree cl;
5428
5429       cl = check_circular_reference (type);
5430       if (! cl)
5431         cl = check_inner_circular_reference (type, type);
5432       if (cl)
5433         parse_error_context (cl, "Cyclic class inheritance%s",
5434                              (cyclic_inheritance_report ?
5435                               cyclic_inheritance_report : ""));
5436     }
5437 }
5438
5439 /* Augment the parameter list PARM with parameters crafted to
5440    initialize outer context locals aliases. Through ARTIFICIAL, a
5441    count is kept of the number of crafted parameters. MODE governs
5442    what eventually gets created: something suitable for a function
5443    creation or a function invocation, either the constructor or
5444    finit$.  */
5445
5446 static tree
5447 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5448                                         int *artificial)
5449 {
5450   tree field;
5451   tree additional_parms = NULL_TREE;
5452
5453   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5454     if (FIELD_LOCAL_ALIAS (field))
5455       {
5456         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5457         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5458         tree mangled_id;
5459
5460         switch (mode)
5461           {
5462           case AIPL_FUNCTION_DECLARATION:
5463             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5464                                                          &buffer [4]);
5465             purpose = build_wfl_node (mangled_id);
5466             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5467               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5468             else
5469               value = TREE_TYPE (field);
5470             break;
5471
5472           case AIPL_FUNCTION_CREATION:
5473             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5474                                                          &buffer [4]);
5475             value = TREE_TYPE (field);
5476             break;
5477
5478           case AIPL_FUNCTION_FINIT_INVOCATION:
5479             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5480                                                          &buffer [4]);
5481             /* Now, this is wrong. purpose should always be the NAME
5482                of something and value its matching value (decl, type,
5483                etc...) FIXME -- but there is a lot to fix. */
5484
5485             /* When invoked for this kind of operation, we already
5486                know whether a field is used or not. */
5487             purpose = TREE_TYPE (field);
5488             value = build_wfl_node (mangled_id);
5489             break;
5490
5491           case AIPL_FUNCTION_CTOR_INVOCATION:
5492             /* There are two case: the constructor invocation happens
5493                outside the local inner, in which case, locales from the outer
5494                context are directly used.
5495
5496                Otherwise, we fold to using the alias directly. */
5497             if (class_type == current_class)
5498               value = field;
5499             else
5500               {
5501                 name = get_identifier (&buffer[4]);
5502                 value = IDENTIFIER_LOCAL_VALUE (name);
5503               }
5504             break;
5505           }
5506         additional_parms = tree_cons (purpose, value, additional_parms);
5507         if (artificial)
5508           *artificial +=1;
5509       }
5510   if (additional_parms)
5511     {
5512       if (ANONYMOUS_CLASS_P (class_type)
5513           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5514         additional_parms = nreverse (additional_parms);
5515       parm = chainon (additional_parms, parm);
5516     }
5517
5518    return parm;
5519 }
5520
5521 /* Craft a constructor for CLASS_DECL -- what we should do when none
5522    where found. ARGS is non NULL when a special signature must be
5523    enforced. This is the case for anonymous classes.  */
5524
5525 static tree
5526 craft_constructor (tree class_decl, tree args)
5527 {
5528   tree class_type = TREE_TYPE (class_decl);
5529   tree parm = NULL_TREE;
5530   /* Inherit access flags for the constructor from its enclosing class. */
5531   int valid_ctor_flags = ACC_PUBLIC | ACC_PROTECTED | ACC_PRIVATE;
5532   int flags = (get_access_flags_from_decl (class_decl) & valid_ctor_flags);
5533   int i = 0, artificial = 0;
5534   tree decl, ctor_name;
5535   char buffer [80];
5536
5537   ctor_name = init_identifier_node;
5538
5539   /* If we're dealing with an inner class constructor, we hide the
5540      this$<n> decl in the name field of its parameter declaration. */
5541   if (PURE_INNER_CLASS_TYPE_P (class_type))
5542     {
5543       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5544       parm = tree_cons (build_current_thisn (class_type),
5545                         build_pointer_type (type), parm);
5546
5547       /* Some more arguments to be hidden here. The values of the local
5548          variables of the outer context that the inner class needs to see. */
5549       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5550                                                      class_type, parm,
5551                                                      &artificial);
5552     }
5553
5554   /* Then if there are any args to be enforced, enforce them now */
5555   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5556     {
5557       /* If we see a `void *', we need to change it to Object.  */
5558       if (TREE_VALUE (args) == TREE_TYPE (null_pointer_node))
5559         TREE_VALUE (args) = object_ptr_type_node;
5560
5561       sprintf (buffer, "parm%d", i++);
5562       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5563     }
5564
5565   CRAFTED_PARAM_LIST_FIXUP (parm);
5566   decl = create_artificial_method (class_type, flags, void_type_node,
5567                                    ctor_name, parm);
5568   fix_method_argument_names (parm, decl);
5569   /* Now, mark the artificial parameters. */
5570   DECL_FUNCTION_NAP (decl) = artificial;
5571   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5572   DECL_INLINE (decl) = 1;
5573   return decl;
5574 }
5575
5576
5577 /* Fix the constructors. This will be called right after circular
5578    references have been checked. It is necessary to fix constructors
5579    early even if no code generation will take place for that class:
5580    some generated constructor might be required by the class whose
5581    compilation triggered this one to be simply loaded.  */
5582
5583 void
5584 java_fix_constructors (void)
5585 {
5586   tree current;
5587
5588   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5589     {
5590       tree class_type = TREE_TYPE (current);
5591       int saw_ctor = 0;
5592       tree decl;
5593
5594       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5595         continue;
5596
5597       output_class = current_class = class_type;
5598       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5599         {
5600           if (DECL_CONSTRUCTOR_P (decl))
5601             {
5602               fix_constructors (decl);
5603               saw_ctor = 1;
5604             }
5605         }
5606
5607       /* Anonymous class constructor can't be generated that early. */
5608       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5609         craft_constructor (current, NULL_TREE);
5610     }
5611 }
5612
5613 /* safe_layout_class just makes sure that we can load a class without
5614    disrupting the current_class, input_file, input_line, etc, information
5615    about the class processed currently.  */
5616
5617 void
5618 safe_layout_class (tree class)
5619 {
5620   tree save_current_class = current_class;
5621   location_t save_location = input_location;
5622
5623   layout_class (class);
5624
5625   current_class = save_current_class;
5626   input_location = save_location;
5627 }
5628
5629 static tree
5630 jdep_resolve_class (jdep *dep)
5631 {
5632   tree decl;
5633
5634   if (JDEP_RESOLVED_P (dep))
5635     decl = JDEP_RESOLVED_DECL (dep);
5636   else
5637     {
5638       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5639                             JDEP_DECL (dep), JDEP_WFL (dep));
5640       JDEP_RESOLVED (dep, decl);
5641       /* If there is no WFL, that's ok.  We generate this warning
5642          elsewhere.  */
5643       if (decl && JDEP_WFL (dep) != NULL_TREE)
5644         check_deprecation (JDEP_WFL (dep), decl);
5645     }
5646
5647   if (!decl)
5648     complete_class_report_errors (dep);
5649   else if (INNER_CLASS_DECL_P (decl))
5650     {
5651       tree inner = TREE_TYPE (decl);
5652       if (! CLASS_LOADED_P (inner))
5653         {
5654           safe_layout_class (inner);
5655           if (TYPE_SIZE (inner) == error_mark_node)
5656             TYPE_SIZE (inner) = NULL_TREE;
5657         }
5658       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5659     }
5660   return decl;
5661 }
5662
5663 /* Complete unsatisfied class declaration and their dependencies */
5664
5665 void
5666 java_complete_class (void)
5667 {
5668   tree cclass;
5669   jdeplist *cclassd;
5670   int error_found;
5671   tree type;
5672
5673   /* Process imports */
5674   process_imports ();
5675
5676   /* Reverse things so we have the right order */
5677   ctxp->class_list = nreverse (ctxp->class_list);
5678   ctxp->classd_list = reverse_jdep_list (ctxp);
5679
5680   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5681        cclass && cclassd;
5682        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5683     {
5684       jdep *dep;
5685
5686       /* We keep the compilation unit imports in the class so that
5687          they can be used later to resolve type dependencies that
5688          aren't necessary to solve now. */
5689       TYPE_IMPORT_LIST (TREE_TYPE (cclass)) = ctxp->import_list;
5690       TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (cclass)) = ctxp->import_demand_list;
5691
5692       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5693         {
5694           tree decl;
5695           if (!(decl = jdep_resolve_class (dep)))
5696             continue;
5697
5698           /* Now it's time to patch */
5699           switch (JDEP_KIND (dep))
5700             {
5701             case JDEP_SUPER:
5702               /* Simply patch super */
5703               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5704                 continue;
5705               BINFO_TYPE (BINFO_BASE_BINFO
5706                           (TYPE_BINFO (TREE_TYPE (JDEP_DECL (dep))), 0))
5707                 = TREE_TYPE (decl);
5708               break;
5709
5710             case JDEP_FIELD:
5711               {
5712                 /* We do part of the job done in add_field */
5713                 tree field_decl = JDEP_DECL (dep);
5714                 tree field_type = TREE_TYPE (decl);
5715                 if (TREE_CODE (field_type) == RECORD_TYPE)
5716                   field_type = promote_type (field_type);
5717                 TREE_TYPE (field_decl) = field_type;
5718                 DECL_ALIGN (field_decl) = 0;
5719                 DECL_USER_ALIGN (field_decl) = 0;
5720                 layout_decl (field_decl, 0);
5721                 SOURCE_FRONTEND_DEBUG
5722                   (("Completed field/var decl '%s' with '%s'",
5723                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5724                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5725                 break;
5726               }
5727             case JDEP_METHOD:   /* We start patching a method */
5728             case JDEP_METHOD_RETURN:
5729               error_found = 0;
5730               while (1)
5731                 {
5732                   if (decl)
5733                     {
5734                       type = TREE_TYPE(decl);
5735                       if (TREE_CODE (type) == RECORD_TYPE)
5736                         type = promote_type (type);
5737                       JDEP_APPLY_PATCH (dep, type);
5738                       SOURCE_FRONTEND_DEBUG
5739                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5740                            "Completing fct '%s' with ret type '%s'":
5741                            "Completing arg '%s' with type '%s'"),
5742                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5743                                               (JDEP_DECL_WFL (dep))),
5744                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5745                     }
5746                   else
5747                     error_found = 1;
5748                   dep = JDEP_CHAIN (dep);
5749                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5750                     break;
5751                   else
5752                     decl = jdep_resolve_class (dep);
5753                 }
5754               if (!error_found)
5755                 {
5756                   tree mdecl = JDEP_DECL (dep), signature;
5757                   /* Recompute and reset the signature, check first that
5758                      all types are now defined. If they're not,
5759                      don't build the signature. */
5760                   if (check_method_types_complete (mdecl))
5761                     {
5762                       signature = build_java_signature (TREE_TYPE (mdecl));
5763                       set_java_signature (TREE_TYPE (mdecl), signature);
5764                     }
5765                 }
5766               else
5767                 continue;
5768               break;
5769
5770             case JDEP_INTERFACE:
5771               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5772                                                 JDEP_WFL (dep)))
5773                 continue;
5774               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5775               break;
5776
5777             case JDEP_PARM:
5778             case JDEP_VARIABLE:
5779               type = TREE_TYPE(decl);
5780               if (TREE_CODE (type) == RECORD_TYPE)
5781                 type = promote_type (type);
5782               JDEP_APPLY_PATCH (dep, type);
5783               break;
5784
5785             case JDEP_TYPE:
5786               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5787               SOURCE_FRONTEND_DEBUG
5788                 (("Completing a random type dependency on a '%s' node",
5789                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5790               break;
5791
5792             case JDEP_EXCEPTION:
5793               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5794               SOURCE_FRONTEND_DEBUG
5795                 (("Completing '%s' 'throws' argument node",
5796                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5797               break;
5798
5799             case JDEP_ANONYMOUS:
5800               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5801               break;
5802
5803             default:
5804               abort ();
5805             }
5806         }
5807     }
5808   return;
5809 }
5810
5811 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5812    array.  */
5813
5814 static tree
5815 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5816 {
5817   tree tname = TYPE_NAME (class_type);
5818   tree resolved_type = TREE_TYPE (class_type);
5819   int array_dims = 0;
5820   tree resolved_type_decl;
5821
5822   if (resolved_type != NULL_TREE)
5823     {
5824       tree resolved_type_decl = TYPE_NAME (resolved_type);
5825       if (resolved_type_decl == NULL_TREE
5826           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5827         {
5828           resolved_type_decl = build_decl (TYPE_DECL,
5829                                            TYPE_NAME (class_type),
5830                                            resolved_type);
5831         }
5832       return resolved_type_decl;
5833     }
5834
5835   /* 1- Check to see if we have an array. If true, find what we really
5836      want to resolve  */
5837   if ((array_dims = build_type_name_from_array_name (tname,
5838                                                      &TYPE_NAME (class_type))))
5839     WFL_STRIP_BRACKET (cl, cl);
5840
5841   /* 2- Resolve the bare type */
5842   if (!(resolved_type_decl = do_resolve_class (enclosing, class_type,
5843                                                decl, cl)))
5844     return NULL_TREE;
5845   resolved_type = TREE_TYPE (resolved_type_decl);
5846
5847   /* 3- If we have an array, reconstruct the array down to its nesting */
5848   if (array_dims)
5849     {
5850       for (; array_dims; array_dims--)
5851         resolved_type = build_java_array_type (resolved_type, -1);
5852       resolved_type_decl = TYPE_NAME (resolved_type);
5853     }
5854   TREE_TYPE (class_type) = resolved_type;
5855   return resolved_type_decl;
5856 }
5857
5858 /* Effectively perform the resolution of class CLASS_TYPE.  DECL or CL
5859    are used to report error messages; CL must either be NULL_TREE or a
5860    WFL wrapping a class.  Do not try to replace TYPE_NAME (class_type)
5861    by a variable, since it is changed by find_in_imports{_on_demand}
5862    and (but it doesn't really matter) qualify_and_find.  */
5863
5864 tree
5865 do_resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5866 {
5867   tree new_class_decl = NULL_TREE, super = NULL_TREE;
5868   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5869   tree decl_result;
5870   htab_t circularity_hash;
5871
5872   if (QUALIFIED_P (TYPE_NAME (class_type)))
5873     {
5874       /* If the type name is of the form `Q . Id', then Q is either a
5875          package name or a class name.  First we try to find Q as a
5876          class and then treat Id as a member type.  If we can't find Q
5877          as a class then we fall through.  */
5878       tree q, left, left_type, right;
5879       if (split_qualified_name (&left, &right, TYPE_NAME (class_type)) == 0)
5880         {
5881           BUILD_PTR_FROM_NAME (left_type, left);
5882           q = do_resolve_class (enclosing, left_type, decl, cl);
5883           if (q)
5884             {
5885               enclosing = q;
5886               saved_enclosing_type = TREE_TYPE (q);
5887               BUILD_PTR_FROM_NAME (class_type, right);
5888             }
5889         }
5890     }
5891
5892   if (enclosing)
5893     {
5894       /* This hash table is used to register the classes we're going
5895          through when searching the current class as an inner class, in
5896          order to detect circular references. Remember to free it before
5897          returning the section 0- of this function. */
5898       circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
5899                                       NULL);
5900
5901       /* 0- Search in the current class as an inner class.
5902          Maybe some code here should be added to load the class or
5903          something, at least if the class isn't an inner class and ended
5904          being loaded from class file. FIXME. */
5905       while (enclosing)
5906         {
5907           new_class_decl = resolve_inner_class (circularity_hash, cl, &enclosing,
5908                                                 &super, class_type);
5909           if (new_class_decl)
5910             break;
5911
5912           /* If we haven't found anything because SUPER reached Object and
5913              ENCLOSING happens to be an innerclass, try the enclosing context. */
5914           if ((!super || super == object_type_node) &&
5915               enclosing && INNER_CLASS_DECL_P (enclosing))
5916             enclosing = DECL_CONTEXT (enclosing);
5917           else
5918             enclosing = NULL_TREE;
5919         }
5920
5921       htab_delete (circularity_hash);
5922
5923       if (new_class_decl)
5924         return new_class_decl;
5925     }
5926
5927   /* 1- Check for the type in single imports. This will change
5928      TYPE_NAME() if something relevant is found */
5929   find_in_imports (saved_enclosing_type, class_type);
5930
5931   /* 2- And check for the type in the current compilation unit */
5932   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5933     {
5934       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
5935         load_class (TYPE_NAME (class_type), 0);
5936       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5937     }
5938
5939   /* 3- Search according to the current package definition */
5940   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5941     {
5942       if ((new_class_decl = qualify_and_find (class_type, ctxp->package,
5943                                              TYPE_NAME (class_type))))
5944         return new_class_decl;
5945     }
5946
5947   /* 4- Check the import on demands. Don't allow bar.baz to be
5948      imported from foo.* */
5949   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5950     if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5951       return NULL_TREE;
5952
5953   /* If found in find_in_imports_on_demand, the type has already been
5954      loaded. */
5955   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5956     return new_class_decl;
5957
5958   /* 5- Try with a name qualified with the package name we've seen so far */
5959   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5960     {
5961       tree package;
5962
5963       /* If there is a current package (ctxp->package), it's the first
5964          element of package_list and we can skip it. */
5965       for (package = (ctxp->package ?
5966                       TREE_CHAIN (package_list) : package_list);
5967            package; package = TREE_CHAIN (package))
5968         if ((new_class_decl = qualify_and_find (class_type,
5969                                                TREE_PURPOSE (package),
5970                                                TYPE_NAME (class_type))))
5971           return new_class_decl;
5972     }
5973
5974   /* 5- Check another compilation unit that bears the name of type */
5975   load_class (TYPE_NAME (class_type), 0);
5976
5977   if (!cl)
5978     cl = lookup_cl (decl);
5979
5980   /* If we don't have a value for CL, then we're being called recursively.
5981      We can't check package access just yet, but it will be taken care of
5982      by the caller. */
5983   if (cl)
5984     {
5985       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true, NULL_TREE))
5986         return NULL_TREE;
5987     }
5988
5989   /* 6- Last call for a resolution */
5990   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5991
5992   /* The final lookup might have registered a.b.c into a.b$c If we
5993      failed at the first lookup, progressively change the name if
5994      applicable and use the matching DECL instead. */
5995   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
5996     {
5997       char *separator;
5998       tree name = TYPE_NAME (class_type);
5999       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
6000
6001       strcpy (namebuffer, IDENTIFIER_POINTER (name));
6002
6003       do {
6004
6005        /* Reach the last '.', and if applicable, replace it by a `$' and
6006           see if this exists as a type. */
6007        if ((separator = strrchr (namebuffer, '.')))
6008          {
6009            *separator = '$';
6010            name = get_identifier (namebuffer);
6011            decl_result = IDENTIFIER_CLASS_VALUE (name);
6012          }
6013       } while (!decl_result && separator);
6014     }
6015   return decl_result;
6016 }
6017
6018 static tree
6019 qualify_and_find (tree class_type, tree package, tree name)
6020 {
6021   tree new_qualified = merge_qualified_name (package, name);
6022   tree new_class_decl;
6023
6024   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
6025     load_class (new_qualified, 0);
6026   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
6027     {
6028       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
6029         load_class (TREE_TYPE (new_class_decl), 0);
6030       TYPE_NAME (class_type) = new_qualified;
6031       return IDENTIFIER_CLASS_VALUE (new_qualified);
6032     }
6033   return NULL_TREE;
6034 }
6035
6036 /* Resolve NAME and lay it out (if not done and if not the current
6037    parsed class). Return a decl node. This function is meant to be
6038    called when type resolution is necessary during the walk pass.  */
6039
6040 static tree
6041 resolve_and_layout (tree something, tree cl)
6042 {
6043   tree decl, decl_type;
6044
6045   /* Don't do that on the current class */
6046   if (something == current_class)
6047     return TYPE_NAME (current_class);
6048
6049   /* Don't do anything for void and other primitive types */
6050   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
6051     return NULL_TREE;
6052
6053   /* Pointer types can be reall pointer types or fake pointers. When
6054      finding a real pointer, recheck for primitive types */
6055   if (TREE_CODE (something) == POINTER_TYPE)
6056     {
6057       if (TREE_TYPE (something))
6058         {
6059           something = TREE_TYPE (something);
6060           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
6061             return NULL_TREE;
6062         }
6063       else
6064         something = TYPE_NAME (something);
6065     }
6066
6067   /* Don't do anything for arrays of primitive types */
6068   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
6069       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
6070     return NULL_TREE;
6071
6072   /* Something might be a WFL */
6073   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
6074     something = EXPR_WFL_NODE (something);
6075
6076   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a a
6077      TYPE_DECL or a real TYPE */
6078   else if (TREE_CODE (something) != IDENTIFIER_NODE)
6079     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
6080             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
6081
6082   if (!(decl = resolve_no_layout (something, cl)))
6083     return NULL_TREE;
6084
6085   /* Resolve and layout if necessary */
6086   decl_type = TREE_TYPE (decl);
6087   layout_class_methods (decl_type);
6088   /* Check methods */
6089   if (CLASS_FROM_SOURCE_P (decl_type))
6090     java_check_methods (decl);
6091   /* Layout the type if necessary */
6092   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
6093     safe_layout_class (decl_type);
6094
6095   return decl;
6096 }
6097
6098 /* Resolve a class, returns its decl but doesn't perform any
6099    layout. The current parsing context is saved and restored */
6100
6101 static tree
6102 resolve_no_layout (tree name, tree cl)
6103 {
6104   tree ptr, decl;
6105   BUILD_PTR_FROM_NAME (ptr, name);
6106   java_parser_context_save_global ();
6107   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
6108   java_parser_context_restore_global ();
6109
6110   return decl;
6111 }
6112
6113 /* Called when reporting errors. Skip the '[]'s in a complex array
6114    type description that failed to be resolved. purify_type_name can't
6115    use an identifier tree.  */
6116
6117 static const char *
6118 purify_type_name (const char *name)
6119 {
6120   int len = strlen (name);
6121   int bracket_found;
6122
6123   STRING_STRIP_BRACKETS (name, len, bracket_found);
6124   if (bracket_found)
6125     {
6126       char *stripped_name = xmemdup (name, len, len+1);
6127       stripped_name [len] = '\0';
6128       return stripped_name;
6129     }
6130   return name;
6131 }
6132
6133 /* The type CURRENT refers to can't be found. We print error messages.  */
6134
6135 static void
6136 complete_class_report_errors (jdep *dep)
6137 {
6138   const char *name;
6139
6140   if (!JDEP_WFL (dep))
6141     return;
6142
6143   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6144   switch (JDEP_KIND (dep))
6145     {
6146     case JDEP_SUPER:
6147       parse_error_context
6148         (JDEP_WFL (dep), "Superclass %qs of class %qs not found",
6149          purify_type_name (name),
6150          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6151       break;
6152     case JDEP_FIELD:
6153       parse_error_context
6154         (JDEP_WFL (dep), "Type %qs not found in declaration of field %qs",
6155          purify_type_name (name),
6156          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6157       break;
6158     case JDEP_METHOD:           /* Covers arguments */
6159       parse_error_context
6160         (JDEP_WFL (dep), "Type %qs not found in the declaration of the argument %qs of method %qs",
6161          purify_type_name (name),
6162          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6163          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6164       break;
6165     case JDEP_METHOD_RETURN:    /* Covers return type */
6166       parse_error_context
6167         (JDEP_WFL (dep), "Type %qs not found in the declaration of the return type of method %qs",
6168          purify_type_name (name),
6169          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6170       break;
6171     case JDEP_INTERFACE:
6172       parse_error_context
6173         (JDEP_WFL (dep), "Superinterface %qs of %s %qs not found",
6174          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6175          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6176          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6177       break;
6178     case JDEP_VARIABLE:
6179       parse_error_context
6180         (JDEP_WFL (dep), "Type %qs not found in the declaration of the local variable %qs",
6181          purify_type_name (IDENTIFIER_POINTER
6182                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6183          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6184       break;
6185     case JDEP_EXCEPTION:        /* As specified by `throws' */
6186       parse_error_context
6187           (JDEP_WFL (dep), "Class %qs not found in %<throws%>",
6188          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6189       break;
6190     default:
6191       /* Fix for -Wall. Just break doing nothing. The error will be
6192          caught later */
6193       break;
6194     }
6195 }
6196
6197 /* Return a static string containing the DECL prototype string. If
6198    DECL is a constructor, use the class name instead of the form
6199    <init> */
6200
6201 static const char *
6202 get_printable_method_name (tree decl)
6203 {
6204   const char *to_return;
6205   tree name = NULL_TREE;
6206
6207   if (DECL_CONSTRUCTOR_P (decl))
6208     {
6209       name = DECL_NAME (decl);
6210       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6211     }
6212
6213   to_return = lang_printable_name (decl, 2);
6214   if (DECL_CONSTRUCTOR_P (decl))
6215     DECL_NAME (decl) = name;
6216
6217   return to_return;
6218 }
6219
6220 /* Track method being redefined inside the same class. As a side
6221    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6222    function it's a FWL, so we can track errors more accurately.)  */
6223
6224 static int
6225 check_method_redefinition (tree class, tree method)
6226 {
6227   tree redef, sig;
6228
6229   /* There's no need to verify <clinit> and finit$ and instinit$ */
6230   if (DECL_CLINIT_P (method)
6231       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6232     return 0;
6233
6234   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6235   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6236     {
6237       if (redef == method)
6238         break;
6239       if (DECL_NAME (redef) == DECL_NAME (method)
6240           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6241           && !DECL_ARTIFICIAL (method))
6242         {
6243           parse_error_context
6244             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration %qs",
6245              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6246              get_printable_method_name (redef));
6247           return 1;
6248         }
6249     }
6250   return 0;
6251 }
6252
6253 /* Return 1 if check went ok, 0 otherwise.  */
6254 static int
6255 check_abstract_method_definitions (int do_interface, tree class_decl,
6256                                    tree type)
6257 {
6258   tree class = TREE_TYPE (class_decl);
6259   tree method, end_type;
6260   int ok = 1;
6261
6262   end_type = (do_interface ? object_type_node : type);
6263   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6264     {
6265       tree other_super, other_method, method_sig, method_name;
6266       int found = 0;
6267       int end_type_reached = 0;
6268
6269       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6270         continue;
6271
6272       /* Now verify that somewhere in between TYPE and CLASS,
6273          abstract method METHOD gets a non abstract definition
6274          that is inherited by CLASS.  */
6275
6276       method_sig = build_java_signature (TREE_TYPE (method));
6277       method_name = DECL_NAME (method);
6278       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6279         method_name = EXPR_WFL_NODE (method_name);
6280
6281       other_super = class;
6282       do {
6283         if (other_super == end_type)
6284           end_type_reached = 1;
6285
6286         /* Method search */
6287         for (other_method = TYPE_METHODS (other_super); other_method;
6288             other_method = TREE_CHAIN (other_method))
6289           {
6290             tree s = build_java_signature (TREE_TYPE (other_method));
6291             tree other_name = DECL_NAME (other_method);
6292
6293             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6294               other_name = EXPR_WFL_NODE (other_name);
6295             if (!DECL_CLINIT_P (other_method)
6296                 && !DECL_CONSTRUCTOR_P (other_method)
6297                 && method_name == other_name
6298                 && method_sig == s
6299                 && !METHOD_ABSTRACT (other_method))
6300              {
6301                found = 1;
6302                break;
6303              }
6304           }
6305         other_super = CLASSTYPE_SUPER (other_super);
6306       } while (!end_type_reached);
6307
6308       /* Report that abstract METHOD didn't find an implementation
6309          that CLASS can use. */
6310       if (!found)
6311         {
6312           char *t = xstrdup (lang_printable_name
6313                             (TREE_TYPE (TREE_TYPE (method)), 0));
6314           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6315
6316           parse_error_context
6317             (lookup_cl (class_decl),
6318              "Class %qs doesn't define the abstract method %<%s %s%> from %s %<%s%>. This method must be defined or %s %qs must be declared abstract",
6319              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6320              t, lang_printable_name (method, 2),
6321              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6322               "interface" : "class"),
6323              IDENTIFIER_POINTER (ccn),
6324              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6325              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6326           ok = 0;
6327           free (t);
6328         }
6329     }
6330
6331   if (ok && do_interface)
6332     {
6333       /* Check for implemented interfaces. */
6334       int i;
6335       tree base_binfo;
6336
6337       for (i = 1;
6338            ok && BINFO_BASE_ITERATE (TYPE_BINFO (type), i, base_binfo);
6339            i++)
6340         ok = check_abstract_method_definitions (1, class_decl,
6341                                                 BINFO_TYPE (base_binfo));
6342     }
6343
6344   return ok;
6345 }
6346
6347 /* Check that CLASS_DECL somehow implements all inherited abstract
6348    methods.  */
6349
6350 static void
6351 java_check_abstract_method_definitions (tree class_decl)
6352 {
6353   tree class = TREE_TYPE (class_decl);
6354   tree super, base_binfo;
6355   int i;
6356
6357   if (CLASS_ABSTRACT (class_decl))
6358     return;
6359
6360   /* Check for inherited types */
6361   super = class;
6362   do {
6363     super = CLASSTYPE_SUPER (super);
6364     check_abstract_method_definitions (0, class_decl, super);
6365   } while (super != object_type_node);
6366
6367   /* Check for implemented interfaces. */
6368   for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6369     check_abstract_method_definitions (1, class_decl, BINFO_TYPE (base_binfo));
6370 }
6371
6372 /* Check all the types method DECL uses and return 1 if all of them
6373    are now complete, 0 otherwise. This is used to check whether its
6374    safe to build a method signature or not.  */
6375
6376 static int
6377 check_method_types_complete (tree decl)
6378 {
6379   tree type = TREE_TYPE (decl);
6380   tree args;
6381
6382   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6383     return 0;
6384
6385   args = TYPE_ARG_TYPES (type);
6386   if (TREE_CODE (type) == METHOD_TYPE)
6387     args = TREE_CHAIN (args);
6388   for (; args != end_params_node; args = TREE_CHAIN (args))
6389     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6390       return 0;
6391
6392   return 1;
6393 }
6394
6395 /* Visible interface to check methods contained in CLASS_DECL */
6396
6397 void
6398 java_check_methods (tree class_decl)
6399 {
6400   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6401     return;
6402
6403   if (CLASS_INTERFACE (class_decl))
6404     java_check_abstract_methods (class_decl);
6405   else
6406     java_check_regular_methods (class_decl);
6407
6408   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6409 }
6410
6411 /* Like not_accessible_p, but doesn't refer to the current class at
6412    all.  */
6413 static bool
6414 hack_is_accessible_p (tree member, tree from_where)
6415 {
6416   int flags = get_access_flags_from_decl (member);
6417
6418   if (from_where == DECL_CONTEXT (member)
6419       || (flags & ACC_PUBLIC))
6420     return true;
6421
6422   if ((flags & ACC_PROTECTED))
6423     {
6424       if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6425         return true;
6426     }
6427
6428   if ((flags & ACC_PRIVATE))
6429     return false;
6430
6431   /* Package private, or protected.  */
6432   return in_same_package (TYPE_NAME (from_where),
6433                           TYPE_NAME (DECL_CONTEXT (member)));
6434 }
6435
6436 /* Check all the methods of CLASS_DECL. Methods are first completed
6437    then checked according to regular method existence rules.  If no
6438    constructor for CLASS_DECL were encountered, then build its
6439    declaration.  */
6440 static void
6441 java_check_regular_methods (tree class_decl)
6442 {
6443   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6444   tree method;
6445   tree class = TREE_TYPE (class_decl);
6446   tree found = NULL_TREE;
6447   tree mthrows;
6448
6449   /* It is not necessary to check methods defined in java.lang.Object */
6450   if (class == object_type_node)
6451     return;
6452
6453   if (!TYPE_NVIRTUALS (class))
6454     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6455
6456   /* Should take interfaces into account. FIXME */
6457   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6458     {
6459       tree sig;
6460       tree method_wfl = DECL_FUNCTION_WFL (method);
6461       int aflags;
6462
6463       /* Check for redefinitions */
6464       if (check_method_redefinition (class, method))
6465         continue;
6466
6467       /* We verify things thrown by the method.  They must inherit from
6468          java.lang.Throwable.  */
6469       for (mthrows = DECL_FUNCTION_THROWS (method);
6470            mthrows; mthrows = TREE_CHAIN (mthrows))
6471         {
6472           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6473             parse_error_context
6474               (TREE_PURPOSE (mthrows), "Class %qs in %<throws%> clause must be a subclass of class %<java.lang.Throwable%>",
6475                IDENTIFIER_POINTER
6476                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6477         }
6478
6479       /* If we see one constructor a mark so we don't generate the
6480          default one.  Also skip other verifications: constructors
6481          can't be inherited hence hidden or overridden.  */
6482       if (DECL_CONSTRUCTOR_P (method))
6483         {
6484           saw_constructor = 1;
6485           continue;
6486         }
6487
6488       sig = build_java_argument_signature (TREE_TYPE (method));
6489       found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6490                                               SEARCH_SUPER | SEARCH_INTERFACE);
6491
6492       /* Inner class can't declare static methods */
6493       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6494         {
6495           char *t = xstrdup (lang_printable_name (class, 0));
6496           parse_error_context
6497             (method_wfl, "Method %qs can't be static in inner class %qs. Only members of interfaces and top-level classes can be static",
6498              lang_printable_name (method, 2), t);
6499           free (t);
6500         }
6501
6502       /* Nothing overrides or it's a private method. */
6503       if (!found)
6504         continue;
6505       if (METHOD_PRIVATE (found))
6506         {
6507           found = NULL_TREE;
6508           continue;
6509         }
6510
6511       /* If `found' is declared in an interface, make sure the
6512          modifier matches. */
6513       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6514           && clinit_identifier_node != DECL_NAME (found)
6515           && !METHOD_PUBLIC (method))
6516         {
6517           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6518           parse_error_context (method_wfl, "Class %qs must override %qs with a public method in order to implement interface %qs",
6519                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6520                                lang_printable_name (method, 2),
6521                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6522         }
6523
6524       /* Can't override a method with the same name and different return
6525          types. */
6526       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6527         {
6528           char *t = xstrdup
6529             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 2));
6530           parse_error_context
6531             (method_wfl,
6532              "Method %qs was defined with return type %qs in class %qs",
6533              lang_printable_name (found, 2), t,
6534              IDENTIFIER_POINTER
6535                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6536           free (t);
6537         }
6538
6539       aflags = get_access_flags_from_decl (found);
6540
6541       /* Can't override final. Can't override static. */
6542       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6543         {
6544           /* Static *can* override static */
6545           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6546             continue;
6547           parse_error_context
6548             (method_wfl,
6549              "%s methods can't be overridden. Method %qs is %s in class %qs",
6550              (METHOD_FINAL (found) ? "Final" : "Static"),
6551              lang_printable_name (found, 2),
6552              (METHOD_FINAL (found) ? "final" : "static"),
6553              IDENTIFIER_POINTER
6554                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6555           continue;
6556         }
6557
6558       /* Static method can't override instance method. */
6559       if (METHOD_STATIC (method))
6560         {
6561           parse_error_context
6562             (method_wfl,
6563              "Instance methods can't be overridden by a static method. Method %qs is an instance method in class %qs",
6564              lang_printable_name (found, 2),
6565              IDENTIFIER_POINTER
6566                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6567           continue;
6568         }
6569
6570       /* - Overriding/hiding public must be public
6571          - Overriding/hiding protected must be protected or public
6572          - If the overridden or hidden method has default (package)
6573            access, then the overriding or hiding method must not be
6574            private; otherwise, a compile-time error occurs.  If
6575            `found' belongs to an interface, things have been already
6576            taken care of.  */
6577       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6578           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6579               || (METHOD_PROTECTED (found)
6580                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6581               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6582                   && METHOD_PRIVATE (method))))
6583         {
6584           parse_error_context
6585             (method_wfl,
6586              "Methods can't be overridden to be more private. Method %qs is not %s in class %qs", lang_printable_name (method, 2),
6587              (METHOD_PUBLIC (method) ? "public" :
6588               (METHOD_PRIVATE (method) ? "private" : "protected")),
6589              IDENTIFIER_POINTER (DECL_NAME
6590                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6591           continue;
6592         }
6593
6594       /* Check this method against all the other implementations it
6595          overrides.  Here we only check the class hierarchy; the rest
6596          of the checking is done later.  If this method is just a
6597          Miranda method, we can skip the check.  */
6598       if (! METHOD_INVISIBLE (method))
6599         check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6600     }
6601
6602   /* The above throws clause check only looked at superclasses.  Now
6603      we must also make sure that all methods declared in interfaces
6604      have compatible throws clauses.  FIXME: there are more efficient
6605      ways to organize this checking; we should implement one.  */
6606   check_interface_throws_clauses (class, class);
6607
6608   if (!TYPE_NVIRTUALS (class))
6609     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6610
6611   /* Search for inherited abstract method not yet implemented in this
6612      class.  */
6613   java_check_abstract_method_definitions (class_decl);
6614
6615   if (!saw_constructor)
6616     abort ();
6617 }
6618
6619 /* Check to make sure that all the methods in all the interfaces
6620    implemented by CLASS_DECL are compatible with the concrete
6621    implementations available in CHECK_CLASS_DECL.  */
6622 static void
6623 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6624 {
6625   for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6626     {
6627       int i;
6628
6629       if (! CLASS_LOADED_P (class_decl))
6630         {
6631           if (CLASS_FROM_SOURCE_P (class_decl))
6632             safe_layout_class (class_decl);
6633           else
6634             load_class (class_decl, 1);
6635         }
6636
6637       for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (class_decl)) - 1; i > 0; --i)
6638         {
6639           tree interface
6640             = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (class_decl), i));
6641           tree iface_method;
6642
6643           for (iface_method = TYPE_METHODS (interface);
6644                iface_method != NULL_TREE;
6645                iface_method = TREE_CHAIN (iface_method))
6646             {
6647               tree sig, method;
6648
6649               /* First look for a concrete method implemented or
6650                  inherited by this class.  No need to search
6651                  interfaces here, since we're already looking through
6652                  all of them.  */
6653               sig = build_java_argument_signature (TREE_TYPE (iface_method));
6654               method
6655                 = lookup_argument_method_generic (check_class_decl,
6656                                                   DECL_NAME (iface_method),
6657                                                   sig, SEARCH_VISIBLE);
6658               /* If we don't find an implementation, that is ok.  Any
6659                  potential errors from that are diagnosed elsewhere.
6660                  Also, multiple inheritance with conflicting throws
6661                  clauses is fine in the absence of a concrete
6662                  implementation.  */
6663               if (method != NULL_TREE && !METHOD_ABSTRACT (method)
6664                   && !METHOD_INVISIBLE (iface_method))
6665                 {
6666                   tree method_wfl = DECL_FUNCTION_WFL (method);
6667                   check_throws_clauses (method, method_wfl, iface_method);
6668                 }
6669             }
6670
6671           /* Now check superinterfaces.  */
6672           check_interface_throws_clauses (check_class_decl, interface);
6673         }
6674     }
6675 }
6676
6677 /* Check throws clauses of a method against the clauses of all the
6678    methods it overrides.  We do this by searching up the class
6679    hierarchy, examining all matching accessible methods.  */
6680 static void
6681 check_concrete_throws_clauses (tree class, tree self_method,
6682                                tree name, tree signature)
6683 {
6684   tree method = lookup_argument_method_generic (class, name, signature,
6685                                                 SEARCH_SUPER | SEARCH_VISIBLE);
6686   while (method != NULL_TREE)
6687     {
6688       if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6689         check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6690                               method);
6691
6692       method = lookup_argument_method_generic (DECL_CONTEXT (method),
6693                                                name, signature,
6694                                                SEARCH_SUPER | SEARCH_VISIBLE);
6695     }
6696 }
6697
6698 /* Generate an error if the `throws' clause of METHOD (if any) is
6699    incompatible with the `throws' clause of FOUND (if any).  */
6700 static void
6701 check_throws_clauses (tree method, tree method_wfl, tree found)
6702 {
6703   tree mthrows;
6704
6705   for (mthrows = DECL_FUNCTION_THROWS (method);
6706        mthrows; mthrows = TREE_CHAIN (mthrows))
6707     {
6708       tree fthrows;
6709
6710       /* We don't verify unchecked expressions */
6711       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6712         continue;
6713       /* Checked expression must be compatible */
6714       for (fthrows = DECL_FUNCTION_THROWS (found);
6715            fthrows; fthrows = TREE_CHAIN (fthrows))
6716         {
6717           if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6718             break;
6719         }
6720       if (!fthrows)
6721         {
6722           parse_error_context
6723             (method_wfl, "Invalid checked exception class %qs in %<throws%> clause.  The exception must be a subclass of an exception thrown by %qs from class %qs",
6724              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6725              lang_printable_name (found, 2),
6726              IDENTIFIER_POINTER
6727              (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6728         }
6729     }
6730 }
6731
6732 /* Check abstract method of interface INTERFACE */
6733 static void
6734 java_check_abstract_methods (tree interface_decl)
6735 {
6736   int i;
6737   tree method, found;
6738   tree interface = TREE_TYPE (interface_decl);
6739   tree base_binfo;
6740
6741   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6742     {
6743       /* 2- Check for double definition inside the defining interface */
6744       if (check_method_redefinition (interface, method))
6745         continue;
6746
6747       /* 3- Overriding is OK as far as we preserve the return type.  */
6748       found = lookup_java_interface_method2 (interface, method);
6749       if (found)
6750         {
6751           char *t;
6752           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 2));
6753           parse_error_context
6754             (DECL_FUNCTION_WFL (found),
6755              "Method %qs was defined with return type %qs in class %qs",
6756              lang_printable_name (found, 2), t,
6757              IDENTIFIER_POINTER
6758                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6759           free (t);
6760           continue;
6761         }
6762     }
6763
6764   /* 4- Inherited methods can't differ by their returned types */
6765   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (interface), i, base_binfo); i++)
6766     {
6767       tree sub_interface_method, sub_interface;
6768
6769       sub_interface = BINFO_TYPE (base_binfo);
6770       for (sub_interface_method = TYPE_METHODS (sub_interface);
6771            sub_interface_method;
6772            sub_interface_method = TREE_CHAIN (sub_interface_method))
6773         {
6774           found = lookup_java_interface_method2 (interface,
6775                                                  sub_interface_method);
6776           if (found && (found != sub_interface_method))
6777             {
6778               parse_error_context
6779                 (lookup_cl (sub_interface_method),
6780                  "Interface %qs inherits method %qs from interface %qs. This method is redefined with a different return type in interface %qs",
6781                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6782                  lang_printable_name (found, 2),
6783                  IDENTIFIER_POINTER
6784                    (DECL_NAME (TYPE_NAME
6785                                (DECL_CONTEXT (sub_interface_method)))),
6786                  IDENTIFIER_POINTER
6787                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6788             }
6789         }
6790     }
6791 }
6792
6793 /* Lookup methods in interfaces using their name and partial
6794    signature. Return a matching method only if their types differ.  */
6795
6796 static tree
6797 lookup_java_interface_method2 (tree class, tree method_decl)
6798 {
6799   int i;
6800   tree base_binfo;
6801   tree to_return;
6802
6803   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6804     {
6805       if ((BINFO_TYPE (base_binfo) != object_type_node)
6806           && (to_return =
6807               lookup_java_method2 (BINFO_TYPE (base_binfo), method_decl, 1)))
6808         return to_return;
6809     }
6810   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6811     {
6812       to_return = lookup_java_interface_method2
6813         (BINFO_TYPE (base_binfo), method_decl);
6814       if (to_return)
6815         return to_return;
6816     }
6817
6818   return NULL_TREE;
6819 }
6820
6821 /* Lookup method using their name and partial signature. Return a
6822    matching method only if their types differ.  */
6823
6824 static tree
6825 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6826 {
6827   tree method, method_signature, method_name, method_type, name;
6828
6829   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6830   name = DECL_NAME (method_decl);
6831   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6832                  EXPR_WFL_NODE (name) : name);
6833   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6834
6835   while (clas != NULL_TREE)
6836     {
6837       for (method = TYPE_METHODS (clas);
6838            method != NULL_TREE;  method = TREE_CHAIN (method))
6839         {
6840           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6841           tree name = DECL_NAME (method);
6842           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6843                EXPR_WFL_NODE (name) : name) == method_name
6844               && method_sig == method_signature
6845               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6846             return method;
6847         }
6848       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6849     }
6850   return NULL_TREE;
6851 }
6852
6853 /* Return the line that matches DECL line number, and try its best to
6854    position the column number. Used during error reports.
6855    FUTURE/FIXME: return source_location instead of node. */
6856
6857 static GTY(()) tree cl_v;
6858 static tree
6859 lookup_cl (tree decl)
6860 {
6861 #ifndef USE_MAPPED_LOCATION
6862   char *line, *found;
6863 #endif
6864
6865   if (!decl)
6866     return NULL_TREE;
6867
6868   if (cl_v == NULL_TREE)
6869     {
6870       cl_v = build_unknown_wfl (NULL_TREE);
6871     }
6872
6873 #ifdef USE_MAPPED_LOCATION
6874   SET_EXPR_LOCATION (cl_v, DECL_SOURCE_LOCATION (decl));
6875 #else
6876   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6877   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6878
6879   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6880                             EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6881
6882   found = strstr ((const char *)line,
6883                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6884   if (found)
6885     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6886 #endif
6887
6888   return cl_v;
6889 }
6890
6891 /* Look for a simple name in the single-type import list */
6892
6893 static tree
6894 find_name_in_single_imports (tree name)
6895 {
6896   tree node;
6897
6898   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6899     if (TREE_VALUE (node) == name)
6900       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6901
6902   return NULL_TREE;
6903 }
6904
6905 /* Process all single-type import. */
6906
6907 static int
6908 process_imports (void)
6909 {
6910   tree import;
6911   int error_found;
6912
6913   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6914     {
6915       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6916       char *original_name;
6917
6918       /* Don't load twice something already defined. */
6919       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6920         continue;
6921
6922       original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6923                                IDENTIFIER_LENGTH (to_be_found),
6924                                IDENTIFIER_LENGTH (to_be_found) + 1);
6925
6926       while (1)
6927         {
6928           tree left;
6929
6930           QUALIFIED_P (to_be_found) = 1;
6931           load_class (to_be_found, 0);
6932           error_found =
6933             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true, NULL_TREE);
6934
6935           /* We found it, we can bail out */
6936           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6937             {
6938               check_deprecation (TREE_PURPOSE (import),
6939                                  IDENTIFIER_CLASS_VALUE (to_be_found));
6940               break;
6941             }
6942
6943           /* We haven't found it. Maybe we're trying to access an
6944              inner class.  The only way for us to know is to try again
6945              after having dropped a qualifier. If we can't break it further,
6946              we have an error. */
6947           if (split_qualified_name (&left, NULL, to_be_found))
6948             break;
6949
6950           to_be_found = left;
6951         }
6952       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6953         {
6954           parse_error_context (TREE_PURPOSE (import),
6955                                "Class or interface %qs not found in import",
6956                                original_name);
6957           error_found = 1;
6958         }
6959
6960       free (original_name);
6961       if (error_found)
6962         return 1;
6963     }
6964   return 0;
6965 }
6966
6967 /* Possibly find and mark a class imported by a single-type import
6968    statement.  */
6969
6970 static void
6971 find_in_imports (tree enclosing_type, tree class_type)
6972 {
6973   tree import = (enclosing_type ? TYPE_IMPORT_LIST (enclosing_type) :
6974                  ctxp->import_list);
6975   while (import)
6976     {
6977       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6978         {
6979           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6980           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6981           return;
6982         }
6983       import = TREE_CHAIN (import);
6984     }
6985 }
6986
6987 static int
6988 note_possible_classname (const char *name, int len)
6989 {
6990   tree node;
6991   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
6992     len = len - 5;
6993   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
6994     len = len - 6;
6995   else
6996     return 0;
6997   node = ident_subst (name, len, "", '/', '.', "");
6998   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
6999   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
7000   return 1;
7001 }
7002
7003 /* Read a import directory, gathering potential match for further type
7004    references. Indifferently reads a filesystem or a ZIP archive
7005    directory.  */
7006
7007 static void
7008 read_import_dir (tree wfl)
7009 {
7010   tree package_id = EXPR_WFL_NODE (wfl);
7011   const char *package_name = IDENTIFIER_POINTER (package_id);
7012   int package_length = IDENTIFIER_LENGTH (package_id);
7013   DIR *dirp = NULL;
7014   JCF *saved_jcf = current_jcf;
7015
7016   int found = 0;
7017   int k;
7018   void *entry;
7019   struct buffer filename[1];
7020
7021   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
7022     return;
7023   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
7024
7025   BUFFER_INIT (filename);
7026   buffer_grow (filename, package_length + 100);
7027
7028   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
7029     {
7030       const char *entry_name = jcf_path_name (entry);
7031       int entry_length = strlen (entry_name);
7032       if (jcf_path_is_zipfile (entry))
7033         {
7034           ZipFile *zipf;
7035           buffer_grow (filename, entry_length);
7036           memcpy (filename->data, entry_name, entry_length - 1);
7037           filename->data[entry_length-1] = '\0';
7038           zipf = opendir_in_zip ((const char *) filename->data, jcf_path_is_system (entry));
7039           if (zipf == NULL)
7040             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
7041           else
7042             {
7043               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
7044               BUFFER_RESET (filename);
7045               for (k = 0; k < package_length; k++)
7046                 {
7047                   char ch = package_name[k];
7048                   *filename->ptr++ = ch == '.' ? '/' : ch;
7049                 }
7050               *filename->ptr++ = '/';
7051
7052               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
7053                 {
7054                   const char *current_entry = ZIPDIR_FILENAME (zipd);
7055                   int current_entry_len = zipd->filename_length;
7056
7057                   if (current_entry_len >= BUFFER_LENGTH (filename)
7058                       && strncmp ((const char *) filename->data, current_entry,
7059                                   BUFFER_LENGTH (filename)) != 0)
7060                     continue;
7061                   found |= note_possible_classname (current_entry,
7062                                                     current_entry_len);
7063                 }
7064             }
7065         }
7066       else
7067         {
7068           BUFFER_RESET (filename);
7069           buffer_grow (filename, entry_length + package_length + 4);
7070           strcpy ((char *) filename->data, entry_name);
7071           filename->ptr = filename->data + entry_length;
7072           for (k = 0; k < package_length; k++)
7073             {
7074               char ch = package_name[k];
7075               *filename->ptr++ = ch == '.' ? '/' : ch;
7076             }
7077           *filename->ptr = '\0';
7078
7079           dirp = opendir ((const char *) filename->data);
7080           if (dirp == NULL)
7081             continue;
7082           *filename->ptr++ = '/';
7083           for (;;)
7084             {
7085               int len;
7086               const char *d_name;
7087               struct dirent *direntp = readdir (dirp);
7088               if (!direntp)
7089                 break;
7090               d_name = direntp->d_name;
7091               len = strlen (direntp->d_name);
7092               buffer_grow (filename, len+1);
7093               strcpy ((char *) filename->ptr, d_name);
7094               found |= note_possible_classname ((const char *) filename->data + entry_length,
7095                                                 package_length+len+1);
7096             }
7097           if (dirp)
7098             closedir (dirp);
7099         }
7100     }
7101
7102   free (filename->data);
7103
7104   /* Here we should have a unified way of retrieving an entry, to be
7105      indexed. */
7106   if (!found)
7107     {
7108       static int first = 1;
7109       if (first)
7110         {
7111           error ("Can't find default package %qs. Check the CLASSPATH environment variable and the access to the archives", package_name);
7112           java_error_count++;
7113           first = 0;
7114         }
7115       else
7116         parse_error_context (wfl, "Package %qs not found in import",
7117                              package_name);
7118       current_jcf = saved_jcf;
7119       return;
7120     }
7121   current_jcf = saved_jcf;
7122 }
7123
7124 /* Possibly find a type in the import on demands specified
7125    types. Returns 1 if an error occurred, 0 otherwise. Run through the
7126    entire list, to detected potential double definitions.  */
7127
7128 static int
7129 find_in_imports_on_demand (tree enclosing_type, tree class_type)
7130 {
7131   tree class_type_name = TYPE_NAME (class_type);
7132   tree import = (enclosing_type ? TYPE_IMPORT_DEMAND_LIST (enclosing_type) :
7133                   ctxp->import_demand_list);
7134   tree cl = NULL_TREE;
7135   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
7136   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
7137   tree node;
7138
7139   for (; import; import = TREE_CHAIN (import))
7140     {
7141       location_t saved_location = input_location;
7142       int access_check;
7143       const char *id_name;
7144       tree decl, type_name_copy;
7145
7146       obstack_grow (&temporary_obstack,
7147                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
7148                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
7149       obstack_1grow (&temporary_obstack, '.');
7150       obstack_grow0 (&temporary_obstack,
7151                      IDENTIFIER_POINTER (class_type_name),
7152                      IDENTIFIER_LENGTH (class_type_name));
7153       id_name = obstack_finish (&temporary_obstack);
7154
7155       if (! (node = maybe_get_identifier (id_name)))
7156         continue;
7157
7158       /* Setup input_line so that it refers to the line of the import (in
7159          case we parse a class file and encounter errors */
7160 #ifdef USE_MAPPED_LOCATION
7161       input_location = EXPR_LOCATION (TREE_PURPOSE (import));
7162 #else
7163       input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
7164 #endif
7165
7166       type_name_copy = TYPE_NAME (class_type);
7167       TYPE_NAME (class_type) = node;
7168       QUALIFIED_P (node) = 1;
7169       decl = IDENTIFIER_CLASS_VALUE (node);
7170       access_check = -1;
7171       /* If there is no DECL set for the class or if the class isn't
7172          loaded and not seen in source yet, then load */
7173       if (!decl || ! CLASS_LOADED_P (TREE_TYPE (decl)))
7174         {
7175           load_class (node, 0);
7176           decl = IDENTIFIER_CLASS_VALUE (node);
7177         }
7178       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7179         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7180                                                false, NULL_TREE);
7181       else
7182         /* 6.6.1: Inner classes are subject to member access rules. */
7183         access_check = 0;
7184
7185       input_location = saved_location;
7186
7187       /* If the loaded class is not accessible or couldn't be loaded,
7188          we restore the original TYPE_NAME and process the next
7189          import. */
7190       if (access_check || !decl)
7191         {
7192           TYPE_NAME (class_type) = type_name_copy;
7193           continue;
7194         }
7195
7196       /* If the loaded class is accessible, we keep a tab on it to
7197          detect and report multiple inclusions. */
7198       if (IS_A_CLASSFILE_NAME (node))
7199         {
7200           if (seen_once < 0)
7201             {
7202               cl = TREE_PURPOSE (import);
7203               seen_once = 1;
7204             }
7205           else if (seen_once >= 0)
7206             {
7207               tree location = (cl ? cl : TREE_PURPOSE (import));
7208               tree package = (cl ? EXPR_WFL_NODE (cl) :
7209                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
7210               seen_once++;
7211               parse_error_context
7212                 (location,
7213                  "Type %qs also potentially defined in package %qs",
7214                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7215                  IDENTIFIER_POINTER (package));
7216             }
7217         }
7218       to_return = access_check;
7219     }
7220
7221   if (seen_once == 1)
7222     return to_return;
7223   else
7224     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7225 }
7226
7227 /* Add package NAME to the list of packages encountered so far. To
7228    speed up class lookup in do_resolve_class, we make sure a
7229    particular package is added only once.  */
7230
7231 static void
7232 register_package (tree name)
7233 {
7234   static htab_t pht;
7235   void **e;
7236
7237   if (pht == NULL)
7238     pht = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
7239
7240   e = htab_find_slot (pht, name, INSERT);
7241   if (*e == NULL)
7242     {
7243       package_list = chainon (package_list, build_tree_list (name, NULL));
7244       *e = name;
7245     }
7246 }
7247
7248 static tree
7249 resolve_package (tree pkg, tree *next, tree *type_name)
7250 {
7251   tree current;
7252   tree decl = NULL_TREE;
7253   *type_name = NULL_TREE;
7254
7255   /* The trick is to determine when the package name stops and were
7256      the name of something contained in the package starts. Then we
7257      return a fully qualified name of what we want to get. */
7258
7259   *next = EXPR_WFL_QUALIFICATION (pkg);
7260
7261   /* Try to progressively construct a type name */
7262   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7263     for (current = EXPR_WFL_QUALIFICATION (pkg);
7264          current; current = TREE_CHAIN (current))
7265       {
7266         /* If we don't have what we're expecting, exit now. TYPE_NAME
7267            will be null and the error caught later. */
7268         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7269           break;
7270         *type_name =
7271           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7272         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7273           {
7274             /* resolve_package should be used in a loop, hence we
7275                point at this one to naturally process the next one at
7276                the next iteration. */
7277             *next = current;
7278             break;
7279           }
7280       }
7281   return decl;
7282 }
7283
7284
7285 /* Check accessibility of inner classes according to member access rules.
7286    DECL is the inner class, ENCLOSING_DECL is the class from which the
7287    access is being attempted. */
7288
7289 static void
7290 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7291 {
7292   const char *access;
7293   tree enclosing_decl_type;
7294
7295   /* We don't issue an error message when CL is null. CL can be null
7296      as a result of processing a JDEP crafted by source_start_java_method
7297      for the purpose of patching its parm decl. But the error would
7298      have been already trapped when fixing the method's signature.
7299      DECL can also be NULL in case of earlier errors. */
7300   if (!decl || !cl)
7301     return;
7302
7303   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7304
7305   if (CLASS_PRIVATE (decl))
7306     {
7307       /* Access is permitted only within the body of the top-level
7308          class in which DECL is declared. */
7309       tree top_level = decl;
7310       while (DECL_CONTEXT (top_level))
7311         top_level = DECL_CONTEXT (top_level);
7312       while (DECL_CONTEXT (enclosing_decl))
7313         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7314       if (top_level == enclosing_decl)
7315         return;
7316       access = "private";
7317     }
7318   else if (CLASS_PROTECTED (decl))
7319     {
7320       tree decl_context;
7321       /* Access is permitted from within the same package... */
7322       if (in_same_package (decl, enclosing_decl))
7323         return;
7324
7325       /* ... or from within the body of a subtype of the context in which
7326          DECL is declared. */
7327       decl_context = DECL_CONTEXT (decl);
7328       while (enclosing_decl)
7329         {
7330           if (CLASS_INTERFACE (decl))
7331             {
7332               if (interface_of_p (TREE_TYPE (decl_context),
7333                                   enclosing_decl_type))
7334                 return;
7335             }
7336           else
7337             {
7338               /* Eww. The order of the arguments is different!! */
7339               if (inherits_from_p (enclosing_decl_type,
7340                                    TREE_TYPE (decl_context)))
7341                 return;
7342             }
7343           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7344         }
7345       access = "protected";
7346     }
7347   else if (! CLASS_PUBLIC (decl))
7348     {
7349       /* Access is permitted only from within the same package as DECL. */
7350       if (in_same_package (decl, enclosing_decl))
7351         return;
7352       access = "non-public";
7353     }
7354   else
7355     /* Class is public. */
7356     return;
7357
7358   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7359                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7360                        lang_printable_name (decl, 2), access);
7361 }
7362
7363 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7364    foreign package, it must be PUBLIC. Return 0 if no access
7365    violations were found, 1 otherwise. If VERBOSE is true and an error
7366    was found, it is reported and accounted for.  If CL is NULL then
7367    look it up with THIS_DECL.  */
7368
7369 static int
7370 check_pkg_class_access (tree class_name, tree cl, bool verbose, tree this_decl)
7371 {
7372   tree type;
7373
7374   if (!IDENTIFIER_CLASS_VALUE (class_name))
7375     return 0;
7376
7377   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7378     return 0;
7379
7380   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7381     {
7382       /* Access to a private class within the same package is
7383          allowed. */
7384       tree l, r;
7385       split_qualified_name (&l, &r, class_name);
7386       if (!QUALIFIED_P (class_name) && !ctxp->package)
7387         /* Both in the empty package. */
7388         return 0;
7389       if (l == ctxp->package)
7390         /* Both in the same package. */
7391         return 0;
7392
7393       if (verbose)
7394         parse_error_context
7395           (cl == NULL ? lookup_cl (this_decl): cl,
7396            "Can't access %s %qs. Only public classes and interfaces in other packages can be accessed",
7397            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7398            IDENTIFIER_POINTER (class_name));
7399       return 1;
7400     }
7401   return 0;
7402 }
7403
7404 /* Local variable declaration. */
7405
7406 static void
7407 declare_local_variables (int modifier, tree type, tree vlist)
7408 {
7409   tree decl, current, saved_type;
7410   tree type_wfl = NULL_TREE;
7411   int must_chain = 0;
7412   int final_p = 0;
7413
7414   /* Push a new block if statements were seen between the last time we
7415      pushed a block and now. Keep a count of blocks to close */
7416   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7417     {
7418       tree b = enter_block ();
7419       BLOCK_IS_IMPLICIT (b) = 1;
7420     }
7421
7422   if (modifier)
7423     {
7424       size_t i;
7425       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7426         if (1 << i & modifier)
7427           break;
7428       if (modifier == ACC_FINAL)
7429         final_p = 1;
7430       else
7431         {
7432           parse_error_context
7433             (ctxp->modifier_ctx [i],
7434              "Only %<final%> is allowed as a local variables modifier");
7435           return;
7436         }
7437     }
7438
7439   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7440      hold the TYPE value if a new incomplete has to be created (as
7441      opposed to being found already existing and reused). */
7442   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7443
7444   /* If TYPE is fully resolved and we don't have a reference, make one */
7445   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7446
7447   /* Go through all the declared variables */
7448   for (current = vlist, saved_type = type; current;
7449        current = TREE_CHAIN (current), type = saved_type)
7450     {
7451       tree other, real_type;
7452       tree wfl  = TREE_PURPOSE (current);
7453       tree name = EXPR_WFL_NODE (wfl);
7454       tree init = TREE_VALUE (current);
7455
7456       /* Process NAME, as it may specify extra dimension(s) for it */
7457       type = build_array_from_name (type, type_wfl, name, &name);
7458
7459       /* Variable redefinition check */
7460       if ((other = lookup_name_in_blocks (name)))
7461         {
7462           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7463                                        DECL_SOURCE_LINE (other));
7464           continue;
7465         }
7466
7467       /* Type adjustment. We may have just readjusted TYPE because
7468          the variable specified more dimensions. Make sure we have
7469          a reference if we can and don't have one already. */
7470       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7471
7472       real_type = GET_REAL_TYPE (type);
7473       /* Never layout this decl. This will be done when its scope
7474          will be entered */
7475       decl = build_decl (VAR_DECL, name, real_type);
7476       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7477       DECL_FINAL (decl) = final_p;
7478       BLOCK_CHAIN_DECL (decl);
7479
7480       /* Don't try to use an INIT statement when an error was found */
7481       if (init && java_error_count)
7482         init = NULL_TREE;
7483
7484       /* Remember it if this is an initialized-upon-declaration final
7485          variable.  */
7486       if (init && final_p)
7487         {
7488           DECL_LOCAL_FINAL_IUD (decl) = 1;
7489         }
7490
7491       /* Add the initialization function to the current function's code */
7492       if (init)
7493         {
7494           /* Name might have been readjusted */
7495           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7496           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7497           java_method_add_stmt (current_function_decl,
7498                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7499                                                       init));
7500         }
7501
7502       /* Setup dependency the type of the decl */
7503       if (must_chain)
7504         {
7505           jdep *dep;
7506           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7507           dep = CLASSD_LAST (ctxp->classd_list);
7508           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7509         }
7510     }
7511   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7512 }
7513
7514 /* Called during parsing. Build decls from argument list.  */
7515
7516 static void
7517 source_start_java_method (tree fndecl)
7518 {
7519   tree tem;
7520   tree parm_decl;
7521   int i;
7522
7523   if (!fndecl)
7524     return;
7525
7526   current_function_decl = fndecl;
7527
7528   /* New scope for the function */
7529   enter_block ();
7530   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7531        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7532     {
7533       tree type = TREE_VALUE (tem);
7534       tree name = TREE_PURPOSE (tem);
7535
7536       /* If type is incomplete. Create an incomplete decl and ask for
7537          the decl to be patched later */
7538       if (INCOMPLETE_TYPE_P (type))
7539         {
7540           jdep *jdep;
7541           tree real_type = GET_REAL_TYPE (type);
7542           parm_decl = build_decl (PARM_DECL, name, real_type);
7543           type = obtain_incomplete_type (type);
7544           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7545           jdep = CLASSD_LAST (ctxp->classd_list);
7546           JDEP_MISC (jdep) = name;
7547           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7548         }
7549       else
7550         parm_decl = build_decl (PARM_DECL, name, type);
7551
7552       /* Remember if a local variable was declared final (via its
7553          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7554       if (ARG_FINAL_P (tem))
7555         {
7556           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7557           DECL_FINAL (parm_decl) = 1;
7558         }
7559
7560       BLOCK_CHAIN_DECL (parm_decl);
7561     }
7562   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7563   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7564     nreverse (tem);
7565   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7566   DECL_MAX_LOCALS (current_function_decl) = i;
7567 }
7568
7569 /* Called during parsing. Creates an artificial method declaration.  */
7570
7571 static tree
7572 create_artificial_method (tree class, int flags, tree type,
7573                           tree name, tree args)
7574 {
7575   tree mdecl;
7576   location_t save_location = input_location;
7577
7578   input_location = DECL_SOURCE_LOCATION (TYPE_NAME (class));
7579   mdecl = make_node (FUNCTION_TYPE);
7580   TREE_TYPE (mdecl) = type;
7581   TYPE_ARG_TYPES (mdecl) = args;
7582   /* We used to compute the signature of MDECL here and then use
7583      add_method(), but that failed because our caller might modify
7584      the type of the returned method, which trashes the cache in
7585      get_type_from_signature().  */
7586   mdecl = add_method_1 (class, flags, name, mdecl);
7587   input_location = save_location;
7588   DECL_ARTIFICIAL (mdecl) = 1;
7589   return mdecl;
7590 }
7591
7592 /* Starts the body if an artificial method.  */
7593
7594 static void
7595 start_artificial_method_body (tree mdecl)
7596 {
7597 #ifdef USE_MAPPED_LOCATION
7598   DECL_SOURCE_LOCATION (mdecl) = ctxp->file_start_location;
7599   DECL_FUNCTION_LAST_LINE (mdecl) = ctxp->file_start_location;
7600 #else
7601   DECL_SOURCE_LINE (mdecl) = 1;
7602   DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7603 #endif
7604   source_start_java_method (mdecl);
7605   enter_block ();
7606 }
7607
7608 static void
7609 end_artificial_method_body (tree mdecl)
7610 {
7611   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7612      It has to be evaluated first. (if mdecl is current_function_decl,
7613      we have an undefined behavior if no temporary variable is used.) */
7614   tree b = exit_block ();
7615   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7616   exit_block ();
7617 }
7618
7619 /* Dump a tree of some kind.  This is a convenience wrapper for the
7620    dump_* functions in tree-dump.c.  */
7621 static void
7622 dump_java_tree (enum tree_dump_index phase, tree t)
7623 {
7624   FILE *stream;
7625   int flags;
7626
7627   stream = dump_begin (phase, &flags);
7628   flags |= TDF_SLIM;
7629   if (stream)
7630     {
7631       dump_node (t, flags, stream);
7632       dump_end (phase, stream);
7633     }
7634 }
7635
7636 /* Terminate a function and expand its body.  */
7637
7638 static void
7639 source_end_java_method (void)
7640 {
7641   tree fndecl = current_function_decl;
7642
7643   if (!fndecl)
7644     return;
7645
7646   java_parser_context_save_global ();
7647 #ifdef USE_MAPPED_LOCATION
7648   input_location = ctxp->last_ccb_indent1;
7649 #else
7650   input_line = ctxp->last_ccb_indent1;
7651 #endif
7652
7653   /* Turn function bodies with only a NOP expr null, so they don't get
7654      generated at all and we won't get warnings when using the -W
7655      -Wall flags. */
7656   if (IS_EMPTY_STMT (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))))
7657     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7658
7659   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
7660       && ! flag_emit_class_files)
7661     finish_method (fndecl);
7662
7663   current_function_decl = NULL_TREE;
7664   java_parser_context_restore_global ();
7665   current_function_decl = NULL_TREE;
7666 }
7667
7668 /* Record EXPR in the current function block. Complements compound
7669    expression second operand if necessary.  */
7670
7671 tree
7672 java_method_add_stmt (tree fndecl, tree expr)
7673 {
7674   if (!GET_CURRENT_BLOCK (fndecl))
7675     return NULL_TREE;
7676   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7677 }
7678
7679 static tree
7680 add_stmt_to_block (tree b, tree type, tree stmt)
7681 {
7682   tree body = BLOCK_EXPR_BODY (b), c;
7683
7684   if (java_error_count)
7685     return body;
7686
7687   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7688     return body;
7689
7690   BLOCK_EXPR_BODY (b) = c;
7691   TREE_SIDE_EFFECTS (c) = 1;
7692   return c;
7693 }
7694
7695 /* Lays out the methods for the classes seen so far.  */
7696
7697 void
7698 java_layout_seen_class_methods (void)
7699 {
7700   tree previous_list = all_class_list;
7701   tree end = NULL_TREE;
7702   tree current;
7703
7704   while (1)
7705     {
7706       for (current = previous_list;
7707            current != end; current = TREE_CHAIN (current))
7708         {
7709           tree decl = TREE_VALUE (current);
7710           tree cls = TREE_TYPE (decl);
7711
7712           input_location = DECL_SOURCE_LOCATION (decl);
7713
7714           if (! CLASS_LOADED_P (cls))
7715             load_class (cls, 0);
7716
7717           layout_class_methods (cls);
7718         }
7719
7720       /* Note that new classes might have been added while laying out
7721          methods, changing the value of all_class_list.  */
7722
7723       if (previous_list != all_class_list)
7724         {
7725           end = previous_list;
7726           previous_list = all_class_list;
7727         }
7728       else
7729         break;
7730     }
7731 }
7732
7733 static GTY(()) tree stop_reordering;
7734 void
7735 java_reorder_fields (void)
7736 {
7737   tree current;
7738
7739   for (current = gclass_list; current; current = TREE_CHAIN (current))
7740     {
7741       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7742
7743       if (current_class == stop_reordering)
7744         break;
7745
7746       /* Reverse the fields, but leave the dummy field in front.
7747          Fields are already ordered for Object and Class */
7748       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7749           && current_class != class_type_node)
7750       {
7751         /* If the dummy field is there, reverse the right fields and
7752            just layout the type for proper fields offset */
7753         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7754           {
7755             tree fields = TYPE_FIELDS (current_class);
7756             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7757             TYPE_SIZE (current_class) = NULL_TREE;
7758           }
7759         /* We don't have a dummy field, we need to layout the class,
7760            after having reversed the fields */
7761         else
7762           {
7763             TYPE_FIELDS (current_class) =
7764               nreverse (TYPE_FIELDS (current_class));
7765             TYPE_SIZE (current_class) = NULL_TREE;
7766           }
7767       }
7768     }
7769   /* There are cases were gclass_list will be empty. */
7770   if (gclass_list)
7771     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7772 }
7773
7774 /* Layout the methods of all classes loaded in one way or another.
7775    Check methods of source parsed classes. Then reorder the
7776    fields and layout the classes or the type of all source parsed
7777    classes */
7778
7779 void
7780 java_layout_classes (void)
7781 {
7782   tree current;
7783   int save_error_count = java_error_count;
7784
7785   /* Layout the methods of all classes seen so far */
7786   java_layout_seen_class_methods ();
7787   java_parse_abort_on_error ();
7788   all_class_list = NULL_TREE;
7789
7790   /* Then check the methods of all parsed classes */
7791   for (current = gclass_list; current; current = TREE_CHAIN (current))
7792     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7793       java_check_methods (TREE_VALUE (current));
7794   java_parse_abort_on_error ();
7795
7796   for (current = gclass_list; current; current = TREE_CHAIN (current))
7797     {
7798       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7799       layout_class (current_class);
7800
7801       /* Error reported by the caller */
7802       if (java_error_count)
7803         return;
7804     }
7805
7806   /* We might have reloaded classes durign the process of laying out
7807      classes for code generation. We must layout the methods of those
7808      late additions, as constructor checks might use them */
7809   java_layout_seen_class_methods ();
7810   java_parse_abort_on_error ();
7811 }
7812
7813 /* Expand methods in the current set of classes remembered for
7814    generation.  */
7815
7816 static void
7817 java_complete_expand_classes (void)
7818 {
7819   tree current;
7820
7821   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7822     if (!INNER_CLASS_DECL_P (current))
7823       java_complete_expand_class (current);
7824 }
7825
7826 /* Expand the methods found in OUTER, starting first by OUTER's inner
7827    classes, if any.  */
7828
7829 static void
7830 java_complete_expand_class (tree outer)
7831 {
7832   tree inner_list;
7833
7834   /* We need to go after all inner classes and start expanding them,
7835      starting with most nested ones. We have to do that because nested
7836      classes might add functions to outer classes */
7837
7838   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7839        inner_list; inner_list = TREE_CHAIN (inner_list))
7840     java_complete_expand_class (TREE_PURPOSE (inner_list));
7841
7842   java_complete_expand_methods (outer);
7843 }
7844
7845 /* Expand methods registered in CLASS_DECL. The general idea is that
7846    we expand regular methods first. This allows us get an estimate on
7847    how outer context local alias fields are really used so we can add
7848    to the constructor just enough code to initialize them properly (it
7849    also lets us generate finit$ correctly.) Then we expand the
7850    constructors and then <clinit>.  */
7851
7852 static void
7853 java_complete_expand_methods (tree class_decl)
7854 {
7855   tree clinit, decl, first_decl;
7856
7857   output_class = current_class = TREE_TYPE (class_decl);
7858
7859   /* Pre-expand <clinit> to figure whether we really need it or
7860      not. If we do need it, we pre-expand the static fields so they're
7861      ready to be used somewhere else. <clinit> will be fully expanded
7862      after we processed the constructors. */
7863   first_decl = TYPE_METHODS (current_class);
7864   clinit = maybe_generate_pre_expand_clinit (current_class);
7865
7866   /* Then generate finit$ (if we need to) because constructors will
7867    try to use it.*/
7868   if (TYPE_FINIT_STMT_LIST (current_class))
7869     java_complete_expand_method (generate_finit (current_class));
7870
7871   /* Then generate instinit$ (if we need to) because constructors will
7872      try to use it. */
7873   if (TYPE_II_STMT_LIST (current_class))
7874     java_complete_expand_method (generate_instinit (current_class));
7875
7876   /* Now do the constructors */
7877   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7878     {
7879       if (!DECL_CONSTRUCTOR_P (decl))
7880         continue;
7881       java_complete_expand_method (decl);
7882     }
7883
7884   /* First, do the ordinary methods. */
7885   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7886     {
7887       /* Ctors aren't part of this batch. */
7888       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7889         continue;
7890
7891       /* Skip abstract or native methods -- but do handle native
7892          methods when generating JNI stubs.  */
7893       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7894         {
7895           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7896           continue;
7897         }
7898
7899       if (METHOD_NATIVE (decl))
7900         {
7901           tree body;
7902           current_function_decl = decl;
7903           body = build_jni_stub (decl);
7904           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7905         }
7906
7907       java_complete_expand_method (decl);
7908     }
7909
7910   /* If there is indeed a <clinit>, fully expand it now */
7911   if (clinit)
7912     {
7913       /* Prevent the use of `this' inside <clinit> */
7914       ctxp->explicit_constructor_p = 1;
7915       java_complete_expand_method (clinit);
7916       ctxp->explicit_constructor_p = 0;
7917     }
7918
7919   /* We might have generated a class$ that we now want to expand */
7920   if (TYPE_DOT_CLASS (current_class))
7921     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7922
7923   /* Now verify constructor circularity (stop after the first one we
7924      prove wrong.) */
7925   if (!CLASS_INTERFACE (class_decl))
7926     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7927       if (DECL_CONSTRUCTOR_P (decl)
7928           && verify_constructor_circularity (decl, decl))
7929         break;
7930 }
7931
7932 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7933    safely used in some other methods/constructors.  */
7934
7935 static tree
7936 maybe_generate_pre_expand_clinit (tree class_type)
7937 {
7938   tree current, mdecl;
7939
7940   if (!TYPE_CLINIT_STMT_LIST (class_type))
7941     return NULL_TREE;
7942
7943   /* Go through all static fields and pre expand them */
7944   for (current = TYPE_FIELDS (class_type); current;
7945        current = TREE_CHAIN (current))
7946     if (FIELD_STATIC (current))
7947       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7948
7949   /* Then build the <clinit> method */
7950   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7951                                     clinit_identifier_node, end_params_node);
7952   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7953                        mdecl, NULL_TREE);
7954   start_artificial_method_body (mdecl);
7955
7956   /* We process the list of assignment we produced as the result of
7957      the declaration of initialized static field and add them as
7958      statement to the <clinit> method. */
7959   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7960        current = TREE_CHAIN (current))
7961     {
7962       tree stmt = current;
7963       /* We build the assignment expression that will initialize the
7964          field to its value. There are strict rules on static
7965          initializers (8.5). FIXME */
7966       if (TREE_CODE (stmt) != BLOCK && !IS_EMPTY_STMT (stmt))
7967         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7968       java_method_add_stmt (mdecl, stmt);
7969     }
7970
7971   end_artificial_method_body (mdecl);
7972
7973   /* Now we want to place <clinit> as the last method (because we need
7974      it at least for interface so that it doesn't interfere with the
7975      dispatch table based lookup. */
7976   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7977     {
7978       current = TREE_CHAIN (TYPE_METHODS (class_type));
7979       TYPE_METHODS (class_type) = current;
7980
7981       while (TREE_CHAIN (current))
7982         current = TREE_CHAIN (current);
7983
7984       TREE_CHAIN (current) = mdecl;
7985       TREE_CHAIN (mdecl) = NULL_TREE;
7986     }
7987
7988   return mdecl;
7989 }
7990
7991 /* Analyzes a method body and look for something that isn't a
7992    MODIFY_EXPR with a constant value.  */
7993
7994 static int
7995 analyze_clinit_body (tree this_class, tree bbody)
7996 {
7997   while (bbody)
7998     switch (TREE_CODE (bbody))
7999       {
8000       case BLOCK:
8001         bbody = BLOCK_EXPR_BODY (bbody);
8002         break;
8003
8004       case EXPR_WITH_FILE_LOCATION:
8005         bbody = EXPR_WFL_NODE (bbody);
8006         break;
8007
8008       case COMPOUND_EXPR:
8009         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
8010           return 1;
8011         bbody = TREE_OPERAND (bbody, 1);
8012         break;
8013
8014       case MODIFY_EXPR:
8015         /* If we're generating to class file and we're dealing with an
8016            array initialization, we return 1 to keep <clinit> */
8017         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
8018             && flag_emit_class_files)
8019           return 1;
8020
8021         /* There are a few cases where we're required to keep
8022            <clinit>:
8023            - If this is an assignment whose operand is not constant,
8024            - If this is an assignment to a non-initialized field,
8025            - If this field is not a member of the current class.
8026         */
8027         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
8028                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
8029                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
8030
8031       default:
8032         return 1;
8033       }
8034   return 0;
8035 }
8036
8037
8038 /* See whether we could get rid of <clinit>. Criteria are: all static
8039    final fields have constant initial values and the body of <clinit>
8040    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
8041
8042 static int
8043 maybe_yank_clinit (tree mdecl)
8044 {
8045   tree type, current;
8046   tree fbody, bbody;
8047
8048   if (!DECL_CLINIT_P (mdecl))
8049     return 0;
8050
8051   /* If the body isn't empty, then we keep <clinit>. Note that if
8052      we're emitting classfiles, this isn't enough not to rule it
8053      out. */
8054   fbody = DECL_FUNCTION_BODY (mdecl);
8055   bbody = BLOCK_EXPR_BODY (fbody);
8056   if (bbody && bbody != error_mark_node)
8057     bbody = BLOCK_EXPR_BODY (bbody);
8058   else
8059     return 0;
8060   if (bbody && ! flag_emit_class_files && !IS_EMPTY_STMT (bbody))
8061     return 0;
8062
8063   type = DECL_CONTEXT (mdecl);
8064   current = TYPE_FIELDS (type);
8065
8066   for (current = (current ? TREE_CHAIN (current) : current);
8067        current; current = TREE_CHAIN (current))
8068     {
8069       tree f_init;
8070
8071       /* We're not interested in non-static fields.  */
8072       if (!FIELD_STATIC (current))
8073         continue;
8074
8075       /* Nor in fields without initializers. */
8076       f_init = DECL_INITIAL (current);
8077       if (f_init == NULL_TREE)
8078         continue;
8079
8080       /* Anything that isn't String or a basic type is ruled out -- or
8081          if we know how to deal with it (when doing things natively) we
8082          should generated an empty <clinit> so that SUID are computed
8083          correctly. */
8084       if (! JSTRING_TYPE_P (TREE_TYPE (current))
8085           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
8086         return 0;
8087
8088       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
8089         return 0;
8090     }
8091
8092   /* Now we analyze the method body and look for something that
8093      isn't a MODIFY_EXPR */
8094   if (bbody && !IS_EMPTY_STMT (bbody) && analyze_clinit_body (type, bbody))
8095     return 0;
8096
8097   /* Get rid of <clinit> in the class' list of methods */
8098   if (TYPE_METHODS (type) == mdecl)
8099     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
8100   else
8101     for (current = TYPE_METHODS (type); current;
8102          current = TREE_CHAIN (current))
8103       if (TREE_CHAIN (current) == mdecl)
8104         {
8105           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
8106           break;
8107         }
8108
8109   return 1;
8110 }
8111
8112 /* Install the argument from MDECL. Suitable to completion and
8113    expansion of mdecl's body.  */
8114
8115 void
8116 start_complete_expand_method (tree mdecl)
8117 {
8118   tree tem;
8119
8120   pushlevel (1);                /* Prepare for a parameter push */
8121   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
8122   DECL_ARGUMENTS (mdecl) = tem;
8123
8124   for (; tem; tem = TREE_CHAIN (tem))
8125     {
8126       /* TREE_CHAIN (tem) will change after pushdecl. */
8127       tree next = TREE_CHAIN (tem);
8128       tree type = TREE_TYPE (tem);
8129       if (targetm.calls.promote_prototypes (type)
8130           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
8131           && INTEGRAL_TYPE_P (type))
8132         type = integer_type_node;
8133       DECL_ARG_TYPE (tem) = type;
8134       layout_decl (tem, 0);
8135       pushdecl (tem);
8136       /* Re-install the next so that the list is kept and the loop
8137          advances. */
8138       TREE_CHAIN (tem) = next;
8139     }
8140   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8141   input_location = DECL_SOURCE_LOCATION (mdecl);
8142   build_result_decl (mdecl);
8143 }
8144
8145
8146 /* Complete and expand a method.  */
8147
8148 static void
8149 java_complete_expand_method (tree mdecl)
8150 {
8151   tree fbody, block_body, exception_copy;
8152
8153   current_function_decl = mdecl;
8154   /* Fix constructors before expanding them */
8155   if (DECL_CONSTRUCTOR_P (mdecl))
8156     fix_constructors (mdecl);
8157
8158   /* Expand functions that have a body */
8159   if (!DECL_FUNCTION_BODY (mdecl))
8160     return;
8161
8162   fbody = DECL_FUNCTION_BODY (mdecl);
8163   block_body = BLOCK_EXPR_BODY (fbody);
8164   exception_copy = NULL_TREE;
8165
8166   current_function_decl = mdecl;
8167
8168   if (! quiet_flag)
8169     fprintf (stderr, " [%s.",
8170              lang_printable_name (DECL_CONTEXT (mdecl), 0));
8171   announce_function (mdecl);
8172   if (! quiet_flag)
8173     fprintf (stderr, "]");
8174
8175   /* Prepare the function for tree completion */
8176   start_complete_expand_method (mdecl);
8177
8178   /* Install the current this */
8179   current_this = (!METHOD_STATIC (mdecl) ?
8180                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8181
8182   /* Purge the `throws' list of unchecked exceptions (we save a copy
8183      of the list and re-install it later.) */
8184   exception_copy = copy_list (DECL_FUNCTION_THROWS (mdecl));
8185   purge_unchecked_exceptions (mdecl);
8186
8187   /* Install exceptions thrown with `throws' */
8188   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8189
8190   if (block_body != NULL_TREE)
8191     {
8192       block_body = java_complete_tree (block_body);
8193
8194       /* Before we check initialization, attached all class initialization
8195          variable to the block_body */
8196       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8197                      attach_init_test_initialization_flags, block_body);
8198
8199       if (! METHOD_NATIVE (mdecl))
8200         {
8201           check_for_initialization (block_body, mdecl);
8202
8203           /* Go through all the flags marking the initialization of
8204              static variables and see whether they're definitively
8205              assigned, in which case the type is remembered as
8206              definitively initialized in MDECL. */
8207           if (STATIC_CLASS_INIT_OPT_P ())
8208             {
8209               /* Always register the context as properly initialized in
8210                  MDECL. This used with caution helps removing extra
8211                  initialization of self. */
8212               if (METHOD_STATIC (mdecl))
8213                 {
8214                   *(htab_find_slot
8215                     (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8216                      DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8217                 }
8218             }
8219         }
8220       ctxp->explicit_constructor_p = 0;
8221     }
8222
8223   BLOCK_EXPR_BODY (fbody) = block_body;
8224
8225   /* If we saw a return but couldn't evaluate it properly, we'll have
8226      an error_mark_node here. */
8227   if (block_body != error_mark_node
8228       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8229       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE)
8230     missing_return_error (current_function_decl);
8231
8232   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8233   maybe_yank_clinit (mdecl);
8234
8235   /* Pop the current level, with special measures if we found errors. */
8236   if (java_error_count)
8237     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8238   poplevel (1, 0, 1);
8239
8240   /* Pop the exceptions and sanity check */
8241   POP_EXCEPTIONS();
8242   if (currently_caught_type_list)
8243     abort ();
8244
8245   /* Restore the copy of the list of exceptions. */
8246   DECL_FUNCTION_THROWS (mdecl) = exception_copy;
8247 }
8248
8249 /* For with each class for which there's code to generate. */
8250
8251 static void
8252 java_expand_method_bodies (tree class)
8253 {
8254   tree decl;
8255   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8256     {
8257       tree block;
8258
8259       if (! DECL_FUNCTION_BODY (decl))
8260         continue;
8261
8262       current_function_decl = decl;
8263
8264       block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8265
8266       /* Save the function body for gimplify and inlining.  */
8267       DECL_SAVED_TREE (decl) = block;
8268
8269       /* It's time to assign the variable flagging static class
8270          initialization based on which classes invoked static methods
8271          are definitely initializing. This should be flagged. */
8272       if (STATIC_CLASS_INIT_OPT_P ())
8273         {
8274           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8275           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8276             {
8277               /* Executed for each statement calling a static function.
8278                  LIST is a TREE_LIST whose PURPOSE is the called function
8279                  and VALUE is a compound whose second operand can be patched
8280                  with static class initialization flag assignments.  */
8281
8282               tree called_method = TREE_PURPOSE (list);
8283               tree compound = TREE_VALUE (list);
8284               tree assignment_compound_list
8285                 = build_tree_list (called_method, NULL);
8286
8287               /* For each class definitely initialized in
8288                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8289                  assignment to the class initialization flag. */
8290               htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8291                              emit_test_initialization,
8292                              assignment_compound_list);
8293
8294               if (TREE_VALUE (assignment_compound_list))
8295                 TREE_OPERAND (compound, 1)
8296                   = TREE_VALUE (assignment_compound_list);
8297             }
8298         }
8299
8300       /* Expand the function body.  */
8301       source_end_java_method ();
8302     }
8303 }
8304
8305 \f
8306
8307 /* This section of the code deals with accessing enclosing context
8308    fields either directly by using the relevant access to this$<n> or
8309    by invoking an access method crafted for that purpose.  */
8310
8311 /* Build the necessary access from an inner class to an outer
8312    class. This routine could be optimized to cache previous result
8313    (decl, current_class and returned access).  When an access method
8314    needs to be generated, it always takes the form of a read. It might
8315    be later turned into a write by calling outer_field_access_fix.  */
8316
8317 static tree
8318 build_outer_field_access (tree id, tree decl)
8319 {
8320   tree access = NULL_TREE;
8321   tree ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8322   tree decl_ctx = DECL_CONTEXT (decl);
8323
8324   /* If the immediate enclosing context of the current class is the
8325      field decl's class or inherits from it; build the access as
8326      `this$<n>.<field>'. Note that we will break the `private' barrier
8327      if we're not emitting bytecodes. */
8328   if ((ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8329       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files ))
8330     {
8331       tree thisn = build_current_thisn (current_class);
8332       access = make_qualified_primary (build_wfl_node (thisn),
8333                                        id, EXPR_WFL_LINECOL (id));
8334     }
8335   /* Otherwise, generate access methods to outer this and access the
8336      field (either using an access method or by direct access.) */
8337   else
8338     {
8339       int lc = EXPR_WFL_LINECOL (id);
8340
8341       /* Now we chain the required number of calls to the access$0 to
8342          get a hold to the enclosing instance we need, and then we
8343          build the field access. */
8344       access = build_access_to_thisn (current_class, decl_ctx, lc);
8345
8346       /* If the field is private and we're generating bytecode, then
8347          we generate an access method */
8348       if (FIELD_PRIVATE (decl) && flag_emit_class_files )
8349         {
8350           tree name = build_outer_field_access_methods (decl);
8351           access = build_outer_field_access_expr (lc, decl_ctx,
8352                                                   name, access, NULL_TREE);
8353         }
8354       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'.
8355          Once again we break the `private' access rule from a foreign
8356          class. */
8357       else
8358         access = make_qualified_primary (access, id, lc);
8359     }
8360   return resolve_expression_name (access, NULL);
8361 }
8362
8363 /* Return a nonzero value if NODE describes an outer field inner
8364    access.  */
8365
8366 static int
8367 outer_field_access_p (tree type, tree decl)
8368 {
8369   if (!INNER_CLASS_TYPE_P (type)
8370       || TREE_CODE (decl) != FIELD_DECL
8371       || DECL_CONTEXT (decl) == type)
8372     return 0;
8373
8374   /* If the inner class extends the declaration context of the field
8375      we're trying to access, then this isn't an outer field access */
8376   if (inherits_from_p (type, DECL_CONTEXT (decl)))
8377     return 0;
8378
8379   for (type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))); ;
8380        type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))))
8381     {
8382       if (type == DECL_CONTEXT (decl))
8383         return 1;
8384
8385       if (!DECL_CONTEXT (TYPE_NAME (type)))
8386         {
8387           /* Before we give up, see whether the field is inherited from
8388              the enclosing context we're considering. */
8389           if (inherits_from_p (type, DECL_CONTEXT (decl)))
8390             return 1;
8391           break;
8392         }
8393     }
8394
8395   return 0;
8396 }
8397
8398 /* Return a nonzero value if NODE represents an outer field inner
8399    access that was been already expanded. As a side effect, it returns
8400    the name of the field being accessed and the argument passed to the
8401    access function, suitable for a regeneration of the access method
8402    call if necessary. */
8403
8404 static int
8405 outer_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8406                                tree *arg)
8407 {
8408   int identified = 0;
8409
8410   if (TREE_CODE (node) != CALL_EXPR)
8411     return 0;
8412
8413   /* Well, gcj generates slightly different tree nodes when compiling
8414      to native or bytecodes. It's the case for function calls. */
8415
8416   if (flag_emit_class_files
8417       && TREE_CODE (node) == CALL_EXPR
8418       && OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8419     identified = 1;
8420   else if (!flag_emit_class_files)
8421     {
8422       node = TREE_OPERAND (node, 0);
8423
8424       if (node && TREE_OPERAND (node, 0)
8425           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8426         {
8427           node = TREE_OPERAND (node, 0);
8428           if (TREE_OPERAND (node, 0)
8429               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8430               && (OUTER_FIELD_ACCESS_IDENTIFIER_P
8431                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8432             identified = 1;
8433         }
8434     }
8435
8436   if (identified && name && arg_type && arg)
8437     {
8438       tree argument = TREE_OPERAND (node, 1);
8439       *name = DECL_NAME (TREE_OPERAND (node, 0));
8440       *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8441       *arg = TREE_VALUE (argument);
8442     }
8443   return identified;
8444 }
8445
8446 /* Detect in NODE an outer field read access from an inner class and
8447    transform it into a write with RHS as an argument. This function is
8448    called from the java_complete_lhs when an assignment to a LHS can
8449    be identified. */
8450
8451 static tree
8452 outer_field_access_fix (tree wfl, tree node, tree rhs)
8453 {
8454   tree name, arg_type, arg;
8455
8456   if (outer_field_expanded_access_p (node, &name, &arg_type, &arg))
8457     {
8458       node = build_outer_field_access_expr (EXPR_WFL_LINECOL (wfl),
8459                                             arg_type, name, arg, rhs);
8460       return java_complete_tree (node);
8461     }
8462   return NULL_TREE;
8463 }
8464
8465 /* Construct the expression that calls an access method:
8466      <type>.access$<n>(<arg1> [, <arg2>]);
8467
8468    ARG2 can be NULL and will be omitted in that case. It will denote a
8469    read access.  */
8470
8471 static tree
8472 build_outer_field_access_expr (int lc, tree type, tree access_method_name,
8473                                tree arg1, tree arg2)
8474 {
8475   tree args, cn, access;
8476
8477   args = arg1 ? arg1 :
8478     build_wfl_node (build_current_thisn (current_class));
8479   args = build_tree_list (NULL_TREE, args);
8480
8481   if (arg2)
8482     args = tree_cons (NULL_TREE, arg2, args);
8483
8484   access = build_method_invocation (build_wfl_node (access_method_name), args);
8485   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8486   return make_qualified_primary (cn, access, lc);
8487 }
8488
8489 static tree
8490 build_new_access_id (void)
8491 {
8492   static int access_n_counter = 1;
8493   char buffer [128];
8494
8495   sprintf (buffer, "access$%d", access_n_counter++);
8496   return get_identifier (buffer);
8497 }
8498
8499 /* Create the static access functions for the outer field DECL. We define a
8500    read:
8501      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8502        return inst$.field;
8503      }
8504    and a write access:
8505      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8506                                      TREE_TYPE (<field>) value$) {
8507        return inst$.field = value$;
8508      }
8509    We should have a usage flags on the DECL so we can lazily turn the ones
8510    we're using for code generation. FIXME.
8511 */
8512
8513 static tree
8514 build_outer_field_access_methods (tree decl)
8515 {
8516   tree id, args, stmt, mdecl;
8517
8518   if (FIELD_INNER_ACCESS_P (decl))
8519     return FIELD_INNER_ACCESS (decl);
8520
8521   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8522
8523   /* Create the identifier and a function named after it. */
8524   id = build_new_access_id ();
8525
8526   /* The identifier is marked as bearing the name of a generated write
8527      access function for outer field accessed from inner classes. */
8528   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8529
8530   /* Create the read access */
8531   args = build_tree_list (inst_id, build_pointer_type (DECL_CONTEXT (decl)));
8532   TREE_CHAIN (args) = end_params_node;
8533   stmt = make_qualified_primary (build_wfl_node (inst_id),
8534                                  build_wfl_node (DECL_NAME (decl)), 0);
8535   stmt = build_return (0, stmt);
8536   mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8537                                            TREE_TYPE (decl), id, args, stmt);
8538   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8539
8540   /* Create the write access method. No write access for final variable */
8541   if (!FIELD_FINAL (decl))
8542     {
8543       args = build_tree_list (inst_id,
8544                               build_pointer_type (DECL_CONTEXT (decl)));
8545       TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8546       TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8547       stmt = make_qualified_primary (build_wfl_node (inst_id),
8548                                      build_wfl_node (DECL_NAME (decl)), 0);
8549       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8550                                                 build_wfl_node (wpv_id)));
8551       mdecl = build_outer_field_access_method (DECL_CONTEXT (decl),
8552                                                TREE_TYPE (decl), id,
8553                                                args, stmt);
8554     }
8555   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8556
8557   /* Return the access name */
8558   return FIELD_INNER_ACCESS (decl) = id;
8559 }
8560
8561 /* Build an field access method NAME.  */
8562
8563 static tree
8564 build_outer_field_access_method (tree class, tree type, tree name,
8565                                  tree args, tree body)
8566 {
8567   tree saved_current_function_decl, mdecl;
8568
8569   /* Create the method */
8570   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8571   fix_method_argument_names (args, mdecl);
8572   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8573
8574   /* Attach the method body. */
8575   saved_current_function_decl = current_function_decl;
8576   start_artificial_method_body (mdecl);
8577   java_method_add_stmt (mdecl, body);
8578   end_artificial_method_body (mdecl);
8579   current_function_decl = saved_current_function_decl;
8580
8581   return mdecl;
8582 }
8583
8584 \f
8585 /* This section deals with building access function necessary for
8586    certain kinds of method invocation from inner classes.  */
8587
8588 static tree
8589 build_outer_method_access_method (tree decl)
8590 {
8591   tree saved_current_function_decl, mdecl;
8592   tree args = NULL_TREE, call_args = NULL_TREE;
8593   tree carg, id, body, class;
8594   char buffer [80];
8595   int parm_id_count = 0;
8596
8597   /* Test this abort with an access to a private field */
8598   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8599     abort ();
8600
8601   /* Check the cache first */
8602   if (DECL_FUNCTION_INNER_ACCESS (decl))
8603     return DECL_FUNCTION_INNER_ACCESS (decl);
8604
8605   class = DECL_CONTEXT (decl);
8606
8607   /* Obtain an access identifier and mark it */
8608   id = build_new_access_id ();
8609   OUTER_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8610
8611   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8612   /* Create the arguments, as much as the original */
8613   for (; carg && carg != end_params_node;
8614        carg = TREE_CHAIN (carg))
8615     {
8616       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8617       args = chainon (args, build_tree_list (get_identifier (buffer),
8618                                              TREE_VALUE (carg)));
8619     }
8620   args = chainon (args, end_params_node);
8621
8622   /* Create the method */
8623   mdecl = create_artificial_method (class, ACC_STATIC,
8624                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8625   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8626   /* There is a potential bug here. We should be able to use
8627      fix_method_argument_names, but then arg names get mixed up and
8628      eventually a constructor will have its this$0 altered and the
8629      outer context won't be assignment properly. The testcase is
8630      stub.java FIXME */
8631   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8632
8633   /* Attach the method body. */
8634   saved_current_function_decl = current_function_decl;
8635   start_artificial_method_body (mdecl);
8636
8637   /* The actual method invocation uses the same args. When invoking a
8638      static methods that way, we don't want to skip the first
8639      argument. */
8640   carg = args;
8641   if (!METHOD_STATIC (decl))
8642     carg = TREE_CHAIN (carg);
8643   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8644     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8645                            call_args);
8646
8647   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8648                                   call_args);
8649   if (!METHOD_STATIC (decl))
8650     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8651                                    body, 0);
8652   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8653     body = build_return (0, body);
8654   java_method_add_stmt (mdecl,body);
8655   end_artificial_method_body (mdecl);
8656   current_function_decl = saved_current_function_decl;
8657
8658   /* Back tag the access function so it know what it accesses */
8659   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8660
8661   /* Tag the current method so it knows it has an access generated */
8662   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8663 }
8664
8665 \f
8666 /* This section of the code deals with building expressions to access
8667    the enclosing instance of an inner class. The enclosing instance is
8668    kept in a generated field called this$<n>, with <n> being the
8669    inner class nesting level (starting from 0.)  */
8670
8671 /* Build an access to a given this$<n>, always chaining access call to
8672    others. Access methods to this$<n> are build on the fly if
8673    necessary. This CAN'T be used to solely access this$<n-1> from
8674    this$<n> (which alway yield to special cases and optimization, see
8675    for example build_outer_field_access).  */
8676
8677 static tree
8678 build_access_to_thisn (tree from, tree to, int lc)
8679 {
8680   tree access = NULL_TREE;
8681
8682   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8683     {
8684       if (!access)
8685         {
8686           access = build_current_thisn (from);
8687           access = build_wfl_node (access);
8688         }
8689       else
8690         {
8691           tree access0_wfl, cn;
8692
8693           maybe_build_thisn_access_method (from);
8694           access0_wfl = build_wfl_node (access0_identifier_node);
8695           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8696           EXPR_WFL_LINECOL (access0_wfl) = lc;
8697           access = build_tree_list (NULL_TREE, access);
8698           access = build_method_invocation (access0_wfl, access);
8699           access = make_qualified_primary (cn, access, lc);
8700         }
8701
8702       /* If FROM isn't an inner class, that's fine, we've done enough.
8703          What we're looking for can be accessed from there.  */
8704       from = DECL_CONTEXT (TYPE_NAME (from));
8705       if (!from)
8706         break;
8707       from = TREE_TYPE (from);
8708     }
8709   return access;
8710 }
8711
8712 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8713    is returned if nothing needs to be generated. Otherwise, the method
8714    generated and a method decl is returned.
8715
8716    NOTE: These generated methods should be declared in a class file
8717    attribute so that they can't be referred to directly.  */
8718
8719 static tree
8720 maybe_build_thisn_access_method (tree type)
8721 {
8722   tree mdecl, args, stmt, rtype;
8723   tree saved_current_function_decl;
8724
8725   /* If TYPE is a top-level class, no access method is required.
8726      If there already is such an access method, bail out. */
8727   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8728     return NULL_TREE;
8729
8730   /* We generate the method. The method looks like:
8731      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8732   */
8733   args = build_tree_list (inst_id, build_pointer_type (type));
8734   TREE_CHAIN (args) = end_params_node;
8735   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8736   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8737                                     access0_identifier_node, args);
8738   fix_method_argument_names (args, mdecl);
8739   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8740   stmt = build_current_thisn (type);
8741   stmt = make_qualified_primary (build_wfl_node (inst_id),
8742                                  build_wfl_node (stmt), 0);
8743   stmt = build_return (0, stmt);
8744
8745   saved_current_function_decl = current_function_decl;
8746   start_artificial_method_body (mdecl);
8747   java_method_add_stmt (mdecl, stmt);
8748   end_artificial_method_body (mdecl);
8749   current_function_decl = saved_current_function_decl;
8750
8751   CLASS_ACCESS0_GENERATED_P (type) = 1;
8752
8753   return mdecl;
8754 }
8755
8756 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8757    the first level of innerclassing. this$1 for the next one, etc...
8758    This function can be invoked with TYPE to NULL, available and then
8759    has to count the parser context.  */
8760
8761 static GTY(()) tree saved_thisn;
8762 static GTY(()) tree saved_type;
8763
8764 static tree
8765 build_current_thisn (tree type)
8766 {
8767   static int saved_i = -1;
8768   static int saved_type_i = 0;
8769   tree decl;
8770   char buffer [24];
8771   int i = 0;
8772
8773   if (type)
8774     {
8775       if (type == saved_type)
8776         i = saved_type_i;
8777       else
8778         {
8779           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8780                decl; decl = DECL_CONTEXT (decl), i++)
8781             ;
8782
8783           saved_type = type;
8784           saved_type_i = i;
8785         }
8786     }
8787   else
8788     i = list_length (GET_CPC_LIST ())-2;
8789
8790   if (i == saved_i)
8791     return saved_thisn;
8792
8793   sprintf (buffer, "this$%d", i);
8794   saved_i = i;
8795   saved_thisn = get_identifier (buffer);
8796   return saved_thisn;
8797 }
8798
8799 /* Return the assignment to the hidden enclosing context `this$<n>'
8800    by the second incoming parameter to the innerclass constructor. The
8801    form used is `this.this$<n> = this$<n>;'.  */
8802
8803 static tree
8804 build_thisn_assign (void)
8805 {
8806   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8807     {
8808       tree thisn = build_current_thisn (current_class);
8809       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8810                                          build_wfl_node (thisn), 0);
8811       tree rhs = build_wfl_node (thisn);
8812 #ifdef USE_MAPPED_LOCATION
8813       SET_EXPR_LOCATION (lhs, input_location);
8814 #else
8815       EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8816 #endif
8817       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8818     }
8819   return NULL_TREE;
8820 }
8821
8822 \f
8823 /* Building the synthetic `class$' used to implement the `.class' 1.1
8824    extension for non primitive types. This method looks like:
8825
8826     static Class class$(String type) throws NoClassDefFoundError
8827     {
8828       try {return (java.lang.Class.forName (String));}
8829       catch (ClassNotFoundException e) {
8830         throw new NoClassDefFoundError(e.getMessage());}
8831     } */
8832
8833 static GTY(()) tree get_message_wfl;
8834 static GTY(()) tree type_parm_wfl;
8835
8836 static tree
8837 build_dot_class_method (tree class)
8838 {
8839 #define BWF(S) build_wfl_node (get_identifier ((S)))
8840 #ifdef USE_MAPPED_LOCATION
8841 #define MQN(X,Y) make_qualified_name ((X), (Y), UNKNOWN_LOCATION)
8842 #else
8843 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8844 #endif
8845   tree args, tmp, saved_current_function_decl, mdecl, qual_name;
8846   tree stmt, throw_stmt;
8847
8848   if (!get_message_wfl)
8849     {
8850       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8851       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8852     }
8853
8854   /* Build the arguments */
8855   args = build_tree_list (get_identifier ("type$"),
8856                           build_pointer_type (string_type_node));
8857   TREE_CHAIN (args) = end_params_node;
8858
8859   /* Build the qualified name java.lang.Class.forName */
8860   tmp = MQN (MQN (MQN (BWF ("java"),
8861                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8862
8863   /* Create the "class$" function */
8864   mdecl = create_artificial_method (class, ACC_STATIC,
8865                                     build_pointer_type (class_type_node),
8866                                     classdollar_identifier_node, args);
8867   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8868                    BWF ("NoClassDefFoundError"));
8869   DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE, qual_name);
8870   register_incomplete_type (JDEP_EXCEPTION, qual_name, NULL_TREE, NULL_TREE);
8871   JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
8872     &TREE_VALUE (DECL_FUNCTION_THROWS (mdecl));
8873
8874   /* We start by building the try block. We need to build:
8875        return (java.lang.Class.forName (type)); */
8876   stmt = build_method_invocation (tmp,
8877                                   build_tree_list (NULL_TREE, type_parm_wfl));
8878   stmt = build_return (0, stmt);
8879
8880   /* Now onto the catch block. We start by building the expression
8881      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8882 #ifdef USE_MAPPED_LOCATION
8883   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8884                                     get_message_wfl, UNKNOWN_LOCATION);
8885 #else
8886   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8887                                     get_message_wfl, 0);
8888 #endif
8889   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
8890
8891   /* Build new NoClassDefFoundError (_.getMessage) */
8892   throw_stmt = build_new_invocation
8893     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
8894      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
8895
8896   /* Build the throw, (it's too early to use BUILD_THROW) */
8897   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
8898
8899   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
8900   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8901                    BWF ("ClassNotFoundException"));
8902   stmt = encapsulate_with_try_catch (0, qual_name, stmt, throw_stmt);
8903
8904   fix_method_argument_names (args, mdecl);
8905   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8906   saved_current_function_decl = current_function_decl;
8907   start_artificial_method_body (mdecl);
8908   java_method_add_stmt (mdecl, stmt);
8909   end_artificial_method_body (mdecl);
8910   current_function_decl = saved_current_function_decl;
8911   TYPE_DOT_CLASS (class) = mdecl;
8912
8913   return mdecl;
8914 }
8915
8916 static tree
8917 build_dot_class_method_invocation (tree this_class, tree type)
8918 {
8919   tree dot_class_method = TYPE_DOT_CLASS (this_class);
8920   tree sig_id, s, t;
8921
8922   if (TYPE_ARRAY_P (type))
8923     sig_id = build_java_signature (type);
8924   else
8925     sig_id = DECL_NAME (TYPE_NAME (type));
8926
8927   /* Ensure that the proper name separator is used */
8928   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
8929                                IDENTIFIER_LENGTH (sig_id));
8930
8931   s = build_string (IDENTIFIER_LENGTH (sig_id),
8932                     IDENTIFIER_POINTER (sig_id));
8933   t = build_method_invocation (build_wfl_node (DECL_NAME (dot_class_method)),
8934                                build_tree_list (NULL_TREE, s));
8935   if (DECL_CONTEXT (dot_class_method) != this_class)
8936     {
8937       tree class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (dot_class_method)));
8938       t = make_qualified_primary (build_wfl_node (class_name), t, 0);
8939     }
8940   return t;
8941 }
8942
8943 /* This section of the code deals with constructor.  */
8944
8945 /* Craft a body for default constructor. Patch existing constructor
8946    bodies with call to super() and field initialization statements if
8947    necessary.  */
8948
8949 static void
8950 fix_constructors (tree mdecl)
8951 {
8952   tree iii;                     /* Instance Initializer Invocation */
8953   tree *bodyp = &DECL_FUNCTION_BODY (mdecl);
8954   tree thisn_assign, compound = NULL_TREE;
8955   tree class_type = DECL_CONTEXT (mdecl);
8956
8957   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
8958     return;
8959   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
8960
8961   if (!*bodyp)
8962     {
8963       /* It is an error for the compiler to generate a default
8964          constructor if the superclass doesn't have a constructor that
8965          takes no argument, or the same args for an anonymous class */
8966       if (verify_constructor_super (mdecl))
8967         {
8968           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
8969           tree save = DECL_NAME (mdecl);
8970           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
8971           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
8972           parse_error_context
8973             (lookup_cl (TYPE_NAME (class_type)),
8974              "No constructor matching %qs found in class %qs",
8975              lang_printable_name (mdecl, 2), n);
8976           DECL_NAME (mdecl) = save;
8977         }
8978
8979       /* The constructor body must be crafted by hand. It's the
8980          constructor we defined when we realize we didn't have the
8981          CLASSNAME() constructor */
8982       start_artificial_method_body (mdecl);
8983
8984       /* Insert an assignment to the this$<n> hidden field, if
8985          necessary */
8986       if ((thisn_assign = build_thisn_assign ()))
8987         java_method_add_stmt (mdecl, thisn_assign);
8988
8989       /* We don't generate a super constructor invocation if we're
8990          compiling java.lang.Object. build_super_invocation takes care
8991          of that. */
8992       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
8993
8994       /* FIXME */
8995       if ((iii = build_instinit_invocation (class_type)))
8996         java_method_add_stmt (mdecl, iii);
8997
8998       end_artificial_method_body (mdecl);
8999     }
9000   /* Search for an explicit constructor invocation */
9001   else
9002     {
9003       int found = 0;
9004       int invokes_this = 0;
9005       tree main_block = BLOCK_EXPR_BODY (*bodyp);
9006
9007       while (*bodyp)
9008         {
9009           tree body = *bodyp;
9010           switch (TREE_CODE (body))
9011             {
9012             case CALL_EXPR:
9013               found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
9014               if (CALL_THIS_CONSTRUCTOR_P (body))
9015                 invokes_this = 1;
9016               break;
9017             case COMPOUND_EXPR:
9018             case EXPR_WITH_FILE_LOCATION:
9019               bodyp = &TREE_OPERAND (body, 0);
9020               continue;
9021             case BLOCK:
9022               bodyp = &BLOCK_EXPR_BODY (body);
9023               continue;
9024             default:
9025               break;
9026             }
9027           break;
9028         }
9029
9030       /* Generate the assignment to this$<n>, if necessary */
9031       if ((thisn_assign = build_thisn_assign ()))
9032         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
9033
9034       /* The constructor is missing an invocation of super() */
9035       if (!found)
9036         compound = add_stmt_to_compound (compound, NULL_TREE,
9037                                          build_super_invocation (mdecl));
9038       /* Explicit super() invocation should take place before the
9039          instance initializer blocks. */
9040       else
9041         {
9042           compound = add_stmt_to_compound (compound, NULL_TREE, *bodyp);
9043           *bodyp = build_java_empty_stmt ();
9044         }
9045
9046       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
9047
9048       /* Insert the instance initializer block right after. */
9049       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
9050         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
9051
9052       /* Fix the constructor main block if we're adding extra stmts */
9053       if (compound)
9054         {
9055           compound = add_stmt_to_compound (compound, NULL_TREE,
9056                                            BLOCK_EXPR_BODY (main_block));
9057           BLOCK_EXPR_BODY (main_block) = compound;
9058         }
9059     }
9060 }
9061
9062 /* Browse constructors in the super class, searching for a constructor
9063    that doesn't take any argument. Return 0 if one is found, 1
9064    otherwise.  If the current class is an anonymous inner class, look
9065    for something that has the same signature. */
9066
9067 static int
9068 verify_constructor_super (tree mdecl)
9069 {
9070   tree class = CLASSTYPE_SUPER (current_class);
9071   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
9072   tree sdecl;
9073
9074   if (!class)
9075     return 0;
9076
9077   if (ANONYMOUS_CLASS_P (current_class))
9078     {
9079       tree mdecl_arg_type;
9080       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
9081       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
9082         if (DECL_CONSTRUCTOR_P (sdecl))
9083           {
9084             tree m_arg_type;
9085             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
9086             if (super_inner)
9087               arg_type = TREE_CHAIN (arg_type);
9088             for (m_arg_type = mdecl_arg_type;
9089                  (arg_type != end_params_node
9090                   && m_arg_type != end_params_node);
9091                  arg_type = TREE_CHAIN (arg_type),
9092                    m_arg_type = TREE_CHAIN (m_arg_type))
9093               if (!valid_method_invocation_conversion_p
9094                      (TREE_VALUE (arg_type),
9095                       TREE_VALUE (m_arg_type)))
9096                 break;
9097
9098             if (arg_type == end_params_node && m_arg_type == end_params_node)
9099               return 0;
9100           }
9101     }
9102   else
9103     {
9104       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
9105         {
9106           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
9107           if (super_inner)
9108             arg = TREE_CHAIN (arg);
9109           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
9110             return 0;
9111         }
9112     }
9113   return 1;
9114 }
9115
9116 /* Generate code for all context remembered for code generation.  */
9117
9118 static GTY(()) tree reversed_class_list;
9119 void
9120 java_expand_classes (void)
9121 {
9122   int save_error_count = 0;
9123   static struct parser_ctxt *cur_ctxp = NULL;
9124   location_t save_location;
9125
9126   java_parse_abort_on_error ();
9127   if (!(ctxp = ctxp_for_generation))
9128     return;
9129   java_layout_classes ();
9130   java_parse_abort_on_error ();
9131   save_location = input_location;
9132
9133   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9134     {
9135       tree current;
9136       for (current = cur_ctxp->class_list;
9137            current;
9138            current = TREE_CHAIN (current))
9139         gen_indirect_dispatch_tables (TREE_TYPE (current));
9140     }
9141
9142   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9143     {
9144       ctxp = cur_ctxp;
9145       input_location = ctxp->file_start_location;
9146       lang_init_source (2);            /* Error msgs have method prototypes */
9147       java_complete_expand_classes (); /* Complete and expand classes */
9148       java_parse_abort_on_error ();
9149     }
9150   input_location = save_location;
9151
9152   /* Find anonymous classes and expand their constructor. This extra pass is
9153      necessary because the constructor itself is only generated when the
9154      method in which it is defined is expanded. */
9155   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9156     {
9157       tree current;
9158       ctxp = cur_ctxp;
9159       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9160         {
9161           output_class = current_class = TREE_TYPE (current);
9162           if (ANONYMOUS_CLASS_P (current_class))
9163             {
9164               tree d;
9165               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9166                 {
9167                   if (DECL_CONSTRUCTOR_P (d))
9168                     {
9169                       java_complete_expand_method (d);
9170                       break;    /* There is only one constructor. */
9171                     }
9172                 }
9173             }
9174         }
9175     }
9176
9177   /* Expanding the constructors of anonymous classes generates access
9178      methods.  Scan all the methods looking for null DECL_RESULTs --
9179      this will be the case if a method hasn't been expanded.  */
9180   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9181     {
9182       tree current;
9183       ctxp = cur_ctxp;
9184       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9185         {
9186           tree d;
9187           output_class = current_class = TREE_TYPE (current);
9188           for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9189             {
9190               if (DECL_RESULT (d) == NULL_TREE)
9191                 java_complete_expand_method (d);
9192             }
9193         }
9194     }
9195
9196   /* ???  Instead of all this we could iterate around the list of
9197      classes until there were no more un-expanded methods.  It would
9198      take a little longer -- one pass over the whole list of methods
9199      -- but it would be simpler.  Like this:  */
9200 #if 0
9201     {
9202       int something_changed;
9203
9204       do
9205         {
9206           something_changed = 0;
9207           for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9208             {
9209               tree current;
9210               ctxp = cur_ctxp;
9211               for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9212                 {
9213                   tree d;
9214                   output_class = current_class = TREE_TYPE (current);
9215                   for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9216                     {
9217                       if (DECL_RESULT (d) == NULL_TREE)
9218                         {
9219                           something_changed = 1;
9220                           java_complete_expand_method (d);
9221                         }
9222                     }
9223                 }
9224             }
9225         }
9226       while (something_changed);
9227     }
9228 #endif
9229
9230   /* If we've found error at that stage, don't try to generate
9231      anything, unless we're checking the syntax only
9232      (but not using -fsyntax-only for the purpose of generating
9233      bytecode).  */
9234   if (java_error_count
9235       && (!flag_syntax_only && !flag_emit_class_files))
9236     return;
9237
9238   /* Now things are stable, go for generation of the class data. */
9239
9240   /* We pessimistically marked all methods and fields external until
9241      we knew what set of classes we were planning to compile.  Now mark
9242      those that will be generated locally as not external.  */
9243   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9244     {
9245       tree current;
9246       ctxp = cur_ctxp;
9247       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9248         java_mark_class_local (TREE_TYPE (current));
9249     }
9250
9251   /* Compile the classes.  */
9252   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9253     {
9254       tree current;
9255       reversed_class_list = NULL;
9256
9257       ctxp = cur_ctxp;
9258
9259       /* We write out the classes in reverse order.  This ensures that
9260          inner classes are written before their containing classes,
9261          which is important for parallel builds.  Otherwise, the
9262          class file for the outer class may be found, but the class
9263          file for the inner class may not be present.  In that
9264          situation, the compiler cannot fall back to the original
9265          source, having already read the outer class, so we must
9266          prevent that situation.  */
9267       for (current = ctxp->class_list;
9268            current;
9269            current = TREE_CHAIN (current))
9270         reversed_class_list
9271           = tree_cons (NULL_TREE, current, reversed_class_list);
9272
9273       for (current = reversed_class_list;
9274            current;
9275            current = TREE_CHAIN (current))
9276         {
9277           output_class = current_class = TREE_TYPE (TREE_VALUE (current));
9278           if (flag_emit_class_files)
9279             write_classfile (current_class);
9280           else if (! flag_syntax_only)
9281             java_expand_method_bodies (current_class);
9282         }
9283     }
9284 }
9285
9286 void
9287 java_finish_classes (void)
9288 {
9289   static struct parser_ctxt *cur_ctxp = NULL;
9290   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9291     {
9292       tree current;
9293       ctxp = cur_ctxp;
9294       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9295         {
9296           output_class = current_class = TREE_TYPE (current);
9297           finish_class ();
9298         }
9299     }
9300 }
9301
9302 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9303    a tree list node containing RIGHT. Fore coming RIGHTs will be
9304    chained to this hook. LOCATION contains the location of the
9305    separating `.' operator.  */
9306
9307 static tree
9308 make_qualified_primary (tree primary, tree right, int location)
9309 {
9310   tree wfl;
9311
9312   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9313     wfl = build_wfl_wrap (primary, location);
9314   else
9315     {
9316       wfl = primary;
9317       /* If wfl wasn't qualified, we build a first anchor */
9318       if (!EXPR_WFL_QUALIFICATION (wfl))
9319         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9320     }
9321
9322   /* And chain them */
9323   EXPR_WFL_LINECOL (right) = location;
9324   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9325   PRIMARY_P (wfl) =  1;
9326   return wfl;
9327 }
9328
9329 /* Simple merge of two name separated by a `.' */
9330
9331 static tree
9332 merge_qualified_name (tree left, tree right)
9333 {
9334   tree node;
9335   if (!left && !right)
9336     return NULL_TREE;
9337
9338   if (!left)
9339     return right;
9340
9341   if (!right)
9342     return left;
9343
9344   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9345                 IDENTIFIER_LENGTH (left));
9346   obstack_1grow (&temporary_obstack, '.');
9347   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9348                  IDENTIFIER_LENGTH (right));
9349   node =  get_identifier (obstack_base (&temporary_obstack));
9350   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9351   QUALIFIED_P (node) = 1;
9352   return node;
9353 }
9354
9355 /* Merge the two parts of a qualified name into LEFT.  Set the
9356    location information of the resulting node to LOCATION, usually
9357    inherited from the location information of the `.' operator. */
9358
9359 static tree
9360 make_qualified_name (tree left, tree right,
9361 #ifdef USE_MAPPED_LOCATION
9362                      source_location location
9363 #else
9364                      int location
9365 #endif
9366                      )
9367 {
9368 #ifdef USE_COMPONENT_REF
9369   tree node = build3 (COMPONENT_REF, NULL_TREE, left, right, NULL_TREE);
9370   SET_EXPR_LOCATION (node, location);
9371   return node;
9372 #else
9373   tree left_id = EXPR_WFL_NODE (left);
9374   tree right_id = EXPR_WFL_NODE (right);
9375   tree wfl, merge;
9376
9377   merge = merge_qualified_name (left_id, right_id);
9378
9379   /* Left wasn't qualified and is now qualified */
9380 #ifdef USE_MAPPED_LOCATION
9381   if (!QUALIFIED_P (left_id))
9382     {
9383       tree wfl = build_expr_wfl (left_id, EXPR_LOCATION (left));
9384       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9385     }
9386
9387   wfl = build_expr_wfl (right_id, location);
9388 #else
9389   if (!QUALIFIED_P (left_id))
9390     {
9391       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9392       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9393       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9394     }
9395
9396   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9397   EXPR_WFL_LINECOL (wfl) = location;
9398 #endif
9399   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9400   EXPR_WFL_NODE (left) = merge;
9401   return left;
9402 #endif
9403 }
9404
9405 /* Extract the last identifier component of the qualified in WFL. The
9406    last identifier is removed from the linked list */
9407
9408 static tree
9409 cut_identifier_in_qualified (tree wfl)
9410 {
9411   tree q;
9412   tree previous = NULL_TREE;
9413   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9414     if (!TREE_CHAIN (q))
9415       {
9416         if (!previous)
9417           /* Operating on a non qualified qualified WFL.  */
9418           abort ();
9419
9420         TREE_CHAIN (previous) = NULL_TREE;
9421         return TREE_PURPOSE (q);
9422       }
9423 }
9424
9425 /* Resolve the expression name NAME. Return its decl.  */
9426
9427 static tree
9428 resolve_expression_name (tree id, tree *orig)
9429 {
9430   tree name = EXPR_WFL_NODE (id);
9431   tree decl;
9432
9433   /* 6.5.5.1: Simple expression names */
9434   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9435     {
9436       /* 15.13.1: NAME can appear within the scope of a local variable
9437          declaration */
9438       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9439         return decl;
9440
9441       /* 15.13.1: NAME can appear within a class declaration */
9442       else
9443         {
9444           decl = lookup_field_wrapper (current_class, name);
9445           if (decl)
9446             {
9447               tree access = NULL_TREE;
9448               int fs = FIELD_STATIC (decl);
9449
9450               /* If we're accessing an outer scope local alias, make
9451                  sure we change the name of the field we're going to
9452                  build access to. */
9453               if (FIELD_LOCAL_ALIAS_USED (decl))
9454                 name = DECL_NAME (decl);
9455
9456               check_deprecation (id, decl);
9457
9458               /* Instance variable (8.3.1.1) can't appear within
9459                  static method, static initializer or initializer for
9460                  a static variable. */
9461               if (!fs && METHOD_STATIC (current_function_decl))
9462                 {
9463                   static_ref_err (id, name, current_class);
9464                   return error_mark_node;
9465                 }
9466               /* Instance variables can't appear as an argument of
9467                  an explicit constructor invocation */
9468               if (!fs && ctxp->explicit_constructor_p
9469                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9470                 {
9471                   parse_error_context
9472                     (id, "Can't reference %qs before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9473                   return error_mark_node;
9474                 }
9475
9476               /* If we're processing an inner class and we're trying
9477                  to access a field belonging to an outer class, build
9478                  the access to the field */
9479               if (!fs && outer_field_access_p (current_class, decl))
9480                 {
9481                   if (CLASS_STATIC (TYPE_NAME (current_class)))
9482                     {
9483                       static_ref_err (id, DECL_NAME (decl), current_class);
9484                       return error_mark_node;
9485                     }
9486                   access = build_outer_field_access (id, decl);
9487                   if (orig)
9488                     *orig = access;
9489                   return access;
9490                 }
9491
9492               /* Otherwise build what it takes to access the field */
9493               access = build_field_ref ((fs ? NULL_TREE : current_this),
9494                                         DECL_CONTEXT (decl), name);
9495               if (fs)
9496                 access = maybe_build_class_init_for_field (decl, access);
9497               /* We may be asked to save the real field access node */
9498               if (orig)
9499                 *orig = access;
9500               /* Last check: can we access the field? */
9501               if (not_accessible_p (current_class, decl, NULL_TREE, 0))
9502                 {
9503                   not_accessible_field_error (id, decl);
9504                   return error_mark_node;
9505                 }
9506               /* And we return what we got */
9507               return access;
9508             }
9509           /* Fall down to error report on undefined variable */
9510         }
9511     }
9512   /* 6.5.5.2 Qualified Expression Names */
9513   else
9514     {
9515       if (orig)
9516         *orig = NULL_TREE;
9517       qualify_ambiguous_name (id);
9518       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9519       /* 15.10.2: Accessing Superclass Members using super */
9520       return resolve_field_access (id, orig, NULL);
9521     }
9522
9523   /* We've got an error here */
9524   if (INNER_CLASS_TYPE_P (current_class))
9525     parse_error_context (id,
9526                          "Local variable %qs can't be accessed from within the inner class %qs unless it is declared final",
9527                          IDENTIFIER_POINTER (name),
9528                          IDENTIFIER_POINTER (DECL_NAME
9529                                              (TYPE_NAME (current_class))));
9530   else
9531     parse_error_context (id, "Undefined variable %qs",
9532                          IDENTIFIER_POINTER (name));
9533
9534   return error_mark_node;
9535 }
9536
9537 static void
9538 static_ref_err (tree wfl, tree field_id, tree class_type)
9539 {
9540   parse_error_context
9541     (wfl,
9542      "Can't make a static reference to nonstatic variable %qs in class %qs",
9543      IDENTIFIER_POINTER (field_id),
9544      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9545 }
9546
9547 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9548    We return something suitable to generate the field access. We also
9549    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9550    recipient's address can be null. */
9551
9552 static tree
9553 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9554 {
9555   int is_static = 0;
9556   tree field_ref;
9557   tree decl = NULL_TREE, where_found, type_found;
9558
9559   if (resolve_qualified_expression_name (qual_wfl, &decl,
9560                                          &where_found, &type_found))
9561     return error_mark_node;
9562
9563   /* Resolve the LENGTH field of an array here */
9564   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9565       && type_found && TYPE_ARRAY_P (type_found)
9566       && ! flag_emit_class_files)
9567     {
9568       tree length = build_java_array_length_access (where_found);
9569       field_ref = length;
9570
9571       /* In case we're dealing with a static array, we need to
9572          initialize its class before the array length can be fetched.
9573          It's also a good time to create a DECL_RTL for the field if
9574          none already exists, otherwise if the field was declared in a
9575          class found in an external file and hasn't been (and won't
9576          be) accessed for its value, none will be created. */
9577       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9578         {
9579           build_static_field_ref (where_found);
9580           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9581         }
9582     }
9583   /* We might have been trying to resolve field.method(). In which
9584      case, the resolution is over and decl is the answer */
9585   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9586     field_ref = decl;
9587   else if (JDECL_P (decl))
9588     {
9589       if (!type_found)
9590         type_found = DECL_CONTEXT (decl);
9591       is_static = FIELD_STATIC (decl);
9592       field_ref = build_field_ref ((is_static ?
9593                                     NULL_TREE : where_found),
9594                                    type_found, DECL_NAME (decl));
9595       if (field_ref == error_mark_node)
9596         return error_mark_node;
9597       if (is_static)
9598         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9599
9600       /* If we're looking at a static field, we may need to generate a
9601          class initialization for it.  This can happen when the access
9602          looks like `field.ref', where `field' is a static field in an
9603          interface we implement.  */
9604       if (!flag_emit_class_files
9605           && TREE_CODE (where_found) == VAR_DECL
9606           && FIELD_STATIC (where_found))
9607         {
9608           build_static_field_ref (where_found);
9609           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9610         }
9611     }
9612   else
9613     field_ref = decl;
9614
9615   if (field_decl)
9616     *field_decl = decl;
9617   if (field_type)
9618     *field_type = (QUAL_DECL_TYPE (decl) ?
9619                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9620   return field_ref;
9621 }
9622
9623 /* If NODE is an access to a static field, strip out the class
9624    initialization part and return the field decl, otherwise, return
9625    NODE. */
9626
9627 tree
9628 extract_field_decl (tree node)
9629 {
9630   if (TREE_CODE (node) == COMPOUND_EXPR)
9631     {
9632       tree op1 = TREE_OPERAND (node, 1);
9633       if (TREE_CODE (op1) == COMPOUND_EXPR)
9634          {
9635            tree call = TREE_OPERAND (op1, 0);
9636            if (TREE_CODE (call) == CALL_EXPR
9637                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9638                && (TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9639                    == soft_initclass_node))
9640              return TREE_OPERAND (op1, 1);
9641          }
9642       else if (JDECL_P (op1))
9643         return op1;
9644     }
9645   return node;
9646 }
9647
9648 /* 6.5.5.2: Qualified Expression Names */
9649
9650 static int
9651 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9652                                    tree *where_found, tree *type_found)
9653 {
9654   int from_type = 0;            /* Field search initiated from a type */
9655   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9656   int previous_call_static = 0;
9657   int is_static;
9658   tree decl = NULL_TREE, type = NULL_TREE, q;
9659   /* For certain for of inner class instantiation */
9660   tree saved_current, saved_this;
9661 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9662   { current_class = saved_current; current_this = saved_this;}
9663
9664   *type_found = *where_found = NULL_TREE;
9665
9666   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9667     {
9668       tree qual_wfl = QUAL_WFL (q);
9669       tree ret_decl;            /* for EH checking */
9670 #ifdef USE_MAPPED_LOCATION
9671       source_location location;  /* for EH checking */
9672 #else
9673       int location;             /* for EH checking */
9674 #endif
9675
9676       /* 15.10.1 Field Access Using a Primary */
9677       switch (TREE_CODE (qual_wfl))
9678         {
9679         case CALL_EXPR:
9680         case NEW_CLASS_EXPR:
9681           /* If the access to the function call is a non static field,
9682              build the code to access it. */
9683           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9684             {
9685               decl = maybe_access_field (decl, *where_found,
9686                                          DECL_CONTEXT (decl));
9687               if (decl == error_mark_node)
9688                 return 1;
9689             }
9690
9691           /* And code for the function call */
9692           if (complete_function_arguments (qual_wfl))
9693             return 1;
9694
9695           /* We might have to setup a new current class and a new this
9696              for the search of an inner class, relative to the type of
9697              a expression resolved as `decl'. The current values are
9698              saved and restored shortly after */
9699           saved_current = current_class;
9700           saved_this = current_this;
9701           if (decl
9702               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9703                   || from_qualified_this))
9704             {
9705               /* If we still have `from_qualified_this', we have the form
9706                  <T>.this.f() and we need to build <T>.this */
9707               if (from_qualified_this)
9708                 {
9709                   decl = build_access_to_thisn (current_class, type, 0);
9710                   decl = java_complete_tree (decl);
9711                   type = TREE_TYPE (TREE_TYPE (decl));
9712                 }
9713               current_class = type;
9714               current_this = decl;
9715               from_qualified_this = 0;
9716             }
9717
9718           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9719             CALL_USING_SUPER (qual_wfl) = 1;
9720 #ifdef USE_MAPPED_LOCATION
9721           location = (TREE_CODE (qual_wfl) == CALL_EXPR
9722                       ? EXPR_LOCATION (TREE_OPERAND (qual_wfl, 0))
9723                       : UNKNOWN_LOCATION);
9724 #else
9725           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9726                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9727 #endif
9728           *where_found = patch_method_invocation (qual_wfl, decl, type,
9729                                                   from_super,
9730                                                   &is_static, &ret_decl);
9731           from_super = 0;
9732           if (*where_found == error_mark_node)
9733             {
9734               RESTORE_THIS_AND_CURRENT_CLASS;
9735               return 1;
9736             }
9737           *type_found = type = QUAL_DECL_TYPE (*where_found);
9738
9739           *where_found = force_evaluation_order (*where_found);
9740
9741           /* If we're creating an inner class instance, check for that
9742              an enclosing instance is in scope */
9743           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9744               && INNER_ENCLOSING_SCOPE_CHECK (type))
9745             {
9746               parse_error_context
9747                 (qual_wfl, "No enclosing instance for inner class %qs is in scope%s",
9748                  lang_printable_name (type, 0),
9749                  (!current_this ? "" :
9750                   "; an explicit one must be provided when creating this inner class"));
9751               RESTORE_THIS_AND_CURRENT_CLASS;
9752               return 1;
9753             }
9754
9755           /* In case we had to change then to resolve a inner class
9756              instantiation using a primary qualified by a `new' */
9757           RESTORE_THIS_AND_CURRENT_CLASS;
9758
9759 #ifdef USE_MAPPED_LOCATION
9760           if (location != UNKNOWN_LOCATION)
9761 #else
9762           if (location)
9763 #endif
9764             {
9765               tree arguments = NULL_TREE;
9766               if (TREE_CODE (qual_wfl) == CALL_EXPR
9767                   && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9768                 arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9769               check_thrown_exceptions (location, ret_decl, arguments);
9770             }
9771
9772           /* If the previous call was static and this one is too,
9773              build a compound expression to hold the two (because in
9774              that case, previous function calls aren't transported as
9775              forcoming function's argument. */
9776           if (previous_call_static && is_static)
9777             {
9778               /* We must set CAN_COMPLETE_NORMALLY for the first call
9779                  since it is done nowhere else.  */
9780               CAN_COMPLETE_NORMALLY (decl) = 1;
9781               decl = build2 (COMPOUND_EXPR, TREE_TYPE (*where_found),
9782                              decl, *where_found);
9783               TREE_SIDE_EFFECTS (decl) = 1;
9784             }
9785           else
9786             {
9787               previous_call_static = is_static;
9788               decl = *where_found;
9789             }
9790           from_type = 0;
9791           continue;
9792
9793         case NEW_ARRAY_EXPR:
9794         case NEW_ANONYMOUS_ARRAY_EXPR:
9795           *where_found = decl = java_complete_tree (qual_wfl);
9796           if (decl == error_mark_node)
9797             return 1;
9798           *type_found = type = QUAL_DECL_TYPE (decl);
9799           continue;
9800
9801         case CONVERT_EXPR:
9802           *where_found = decl = java_complete_tree (qual_wfl);
9803           if (decl == error_mark_node)
9804             return 1;
9805           *type_found = type = QUAL_DECL_TYPE (decl);
9806           from_cast = 1;
9807           continue;
9808
9809         case CONDITIONAL_EXPR:
9810         case STRING_CST:
9811         case MODIFY_EXPR:
9812           *where_found = decl = java_complete_tree (qual_wfl);
9813           if (decl == error_mark_node)
9814             return 1;
9815           *type_found = type = QUAL_DECL_TYPE (decl);
9816           continue;
9817
9818         case ARRAY_REF:
9819           /* If the access to the function call is a non static field,
9820              build the code to access it. */
9821           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9822             {
9823               decl = maybe_access_field (decl, *where_found, type);
9824               if (decl == error_mark_node)
9825                 return 1;
9826             }
9827           /* And code for the array reference expression */
9828           decl = java_complete_tree (qual_wfl);
9829           if (decl == error_mark_node)
9830             return 1;
9831           type = QUAL_DECL_TYPE (decl);
9832           continue;
9833
9834         case PLUS_EXPR:
9835           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9836             return 1;
9837           if ((type = patch_string (decl)))
9838             decl = type;
9839           *where_found = QUAL_RESOLUTION (q) = decl;
9840           *type_found = type = TREE_TYPE (decl);
9841           break;
9842
9843         case CLASS_LITERAL:
9844           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9845             return 1;
9846           *where_found = QUAL_RESOLUTION (q) = decl;
9847           *type_found = type = TREE_TYPE (decl);
9848           break;
9849
9850         default:
9851           /* Fix for -Wall Just go to the next statement. Don't
9852              continue */
9853           break;
9854         }
9855
9856       /* If we fall here, we weren't processing a (static) function call. */
9857       previous_call_static = 0;
9858
9859       /* It can be the keyword THIS */
9860       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9861           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9862         {
9863           if (!current_this)
9864             {
9865               parse_error_context
9866                 (wfl, "Keyword %<this%> used outside allowed context");
9867               return 1;
9868             }
9869           if (ctxp->explicit_constructor_p
9870               && type == current_class)
9871             {
9872               parse_error_context (wfl, "Can't reference %<this%> before the superclass constructor has been called");
9873               return 1;
9874             }
9875           /* We have to generate code for intermediate access */
9876           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
9877             {
9878               *where_found = decl = current_this;
9879               *type_found = type = QUAL_DECL_TYPE (decl);
9880             }
9881           /* We're trying to access the this from somewhere else. Make sure
9882              it's allowed before doing so. */
9883           else
9884             {
9885               if (!enclosing_context_p (type, current_class))
9886                 {
9887                   char *p  = xstrdup (lang_printable_name (type, 0));
9888                   parse_error_context (qual_wfl, "Can't use variable %<%s.this%>: type %qs isn't an outer type of type %qs",
9889                                        p, p,
9890                                        lang_printable_name (current_class, 0));
9891                   free (p);
9892                   return 1;
9893                 }
9894               from_qualified_this = 1;
9895               /* If there's nothing else after that, we need to
9896                  produce something now, otherwise, the section of the
9897                  code that needs to produce <T>.this will generate
9898                  what is necessary. */
9899               if (!TREE_CHAIN (q))
9900                 {
9901                   decl = build_access_to_thisn (current_class, type, 0);
9902                   *where_found = decl = java_complete_tree (decl);
9903                   *type_found = type = TREE_TYPE (decl);
9904                 }
9905             }
9906
9907           from_type = 0;
9908           continue;
9909         }
9910
9911       /* 15.10.2 Accessing Superclass Members using SUPER */
9912       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9913           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
9914         {
9915           tree node;
9916           /* Check on the restricted use of SUPER */
9917           if (METHOD_STATIC (current_function_decl)
9918               || current_class == object_type_node)
9919             {
9920               parse_error_context
9921                 (wfl, "Keyword %<super%> used outside allowed context");
9922               return 1;
9923             }
9924           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
9925           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
9926                              CLASSTYPE_SUPER (current_class),
9927                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
9928           *where_found = decl = java_complete_tree (node);
9929           if (decl == error_mark_node)
9930             return 1;
9931           *type_found = type = QUAL_DECL_TYPE (decl);
9932           from_super = from_type = 1;
9933           continue;
9934         }
9935
9936       /* 15.13.1: Can't search for field name in packages, so we
9937          assume a variable/class name was meant. */
9938       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
9939         {
9940           tree name;
9941           if ((decl = resolve_package (wfl, &q, &name)))
9942             {
9943               tree list;
9944               *where_found = decl;
9945
9946               check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
9947
9948               /* We want to be absolutely sure that the class is laid
9949                  out. We're going to search something inside it. */
9950               *type_found = type = TREE_TYPE (decl);
9951               layout_class (type);
9952               from_type = 1;
9953
9954               /* Fix them all the way down, if any are left. */
9955               if (q)
9956                 {
9957                   list = TREE_CHAIN (q);
9958                   while (list)
9959                     {
9960                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
9961                       list = TREE_CHAIN (list);
9962                     }
9963                 }
9964             }
9965           else
9966             {
9967               if (from_super || from_cast)
9968                 parse_error_context
9969                   ((from_cast ? qual_wfl : wfl),
9970                    "No variable %qs defined in class %qs",
9971                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
9972                    lang_printable_name (type, 0));
9973               else
9974                 parse_error_context
9975                   (qual_wfl, "Undefined variable or class name: %qs",
9976                    IDENTIFIER_POINTER (name));
9977               return 1;
9978             }
9979         }
9980
9981       /* We have a type name. It's been already resolved when the
9982          expression was qualified. */
9983       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
9984         {
9985           decl = QUAL_RESOLUTION (q);
9986
9987           /* Sneak preview. If next we see a `new', we're facing a
9988              qualification which resulted in a type being selected
9989              instead of a field.  Report the error.  */
9990           if(TREE_CHAIN (q)
9991              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
9992             {
9993               parse_error_context (qual_wfl, "Undefined variable %qs",
9994                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
9995               return 1;
9996             }
9997
9998           check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
9999
10000           check_deprecation (qual_wfl, decl);
10001
10002           type = TREE_TYPE (decl);
10003           from_type = 1;
10004         }
10005       /* We resolve an expression name */
10006       else
10007         {
10008           tree field_decl = NULL_TREE;
10009
10010           /* If there exists an early resolution, use it. That occurs
10011              only once and we know that there are more things to
10012              come. Don't do that when processing something after SUPER
10013              (we need more thing to be put in place below */
10014           if (!from_super && QUAL_RESOLUTION (q))
10015             {
10016               decl = QUAL_RESOLUTION (q);
10017               if (!type)
10018                 {
10019                   if (TREE_CODE (decl) == FIELD_DECL && !FIELD_STATIC (decl))
10020                     {
10021                       if (current_this)
10022                         *where_found = current_this;
10023                       else
10024                         {
10025                           static_ref_err (qual_wfl, DECL_NAME (decl),
10026                                           current_class);
10027                           return 1;
10028                         }
10029                       if (outer_field_access_p (current_class, decl))
10030                         decl = build_outer_field_access (qual_wfl, decl);
10031                     }
10032                   else
10033                     {
10034                       *where_found = TREE_TYPE (decl);
10035                       if (TREE_CODE (*where_found) == POINTER_TYPE)
10036                         *where_found = TREE_TYPE (*where_found);
10037                     }
10038                 }
10039             }
10040
10041           /* Report and error if we're using a numerical literal as a
10042              qualifier. It can only be an INTEGER_CST. */
10043           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
10044             {
10045               parse_error_context
10046                 (wfl, "Can't use type %qs as a qualifier",
10047                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
10048               return 1;
10049             }
10050
10051           /* We have to search for a field, knowing the type of its
10052              container. The flag FROM_TYPE indicates that we resolved
10053              the last member of the expression as a type name, which
10054              means that for the resolution of this field, we'll look
10055              for other errors than if it was resolved as a member of
10056              an other field. */
10057           else
10058             {
10059               int is_static;
10060               tree field_decl_type; /* For layout */
10061
10062               if (!from_type && !JREFERENCE_TYPE_P (type))
10063                 {
10064                   parse_error_context
10065                     (qual_wfl, "Attempt to reference field %qs in %<%s %s%>",
10066                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
10067                      lang_printable_name (type, 0),
10068                      IDENTIFIER_POINTER (DECL_NAME (decl)));
10069                   return 1;
10070                 }
10071
10072               field_decl = lookup_field_wrapper (type,
10073                                                  EXPR_WFL_NODE (qual_wfl));
10074
10075               /* Maybe what we're trying to access to is an inner
10076                  class, only if decl is a TYPE_DECL. */
10077               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
10078                 {
10079                   tree ptr, inner_decl;
10080
10081                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
10082                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
10083                   if (inner_decl)
10084                     {
10085                       check_inner_class_access (inner_decl, decl, qual_wfl);
10086                       type = TREE_TYPE (inner_decl);
10087                       decl = inner_decl;
10088                       from_type = 1;
10089                       continue;
10090                     }
10091                 }
10092
10093               if (field_decl == NULL_TREE)
10094                 {
10095                   parse_error_context
10096                     (qual_wfl, "No variable %qs defined in type %qs",
10097                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
10098                      GET_TYPE_NAME (type));
10099                   return 1;
10100                 }
10101               if (field_decl == error_mark_node)
10102                 return 1;
10103
10104               /* Layout the type of field_decl, since we may need
10105                  it. Don't do primitive types or loaded classes. The
10106                  situation of non primitive arrays may not handled
10107                  properly here. FIXME */
10108               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
10109                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
10110               else
10111                 field_decl_type = TREE_TYPE (field_decl);
10112               if (!JPRIMITIVE_TYPE_P (field_decl_type)
10113                   && !CLASS_LOADED_P (field_decl_type)
10114                   && !TYPE_ARRAY_P (field_decl_type))
10115                 resolve_and_layout (field_decl_type, NULL_TREE);
10116
10117               /* Check on accessibility here */
10118               if (not_accessible_p (current_class, field_decl,
10119                                     *type_found, from_super))
10120                 return not_accessible_field_error (qual_wfl,field_decl);
10121               check_deprecation (qual_wfl, field_decl);
10122
10123               /* There are things to check when fields are accessed
10124                  from type. There are no restrictions on a static
10125                  declaration of the field when it is accessed from an
10126                  interface */
10127               is_static = FIELD_STATIC (field_decl);
10128               if (!from_super && from_type
10129                   && !TYPE_INTERFACE_P (type)
10130                   && !is_static
10131                   && (current_function_decl
10132                       && METHOD_STATIC (current_function_decl)))
10133                 {
10134                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
10135                   return 1;
10136                 }
10137               from_cast = from_super = 0;
10138
10139               /* It's an access from a type but it isn't static, we
10140                  make it relative to `this'. */
10141               if (!is_static && from_type)
10142                 decl = current_this;
10143
10144               /* If we need to generate something to get a proper
10145                  handle on what this field is accessed from, do it
10146                  now. */
10147               if (!is_static)
10148                 {
10149                   decl = maybe_access_field (decl, *where_found, *type_found);
10150                   if (decl == error_mark_node)
10151                     return 1;
10152                 }
10153
10154               /* We want to keep the location were found it, and the type
10155                  we found. */
10156               *where_found = decl;
10157               *type_found = type;
10158
10159               /* Generate the correct expression for field access from
10160                  qualified this */
10161               if (from_qualified_this)
10162                 {
10163                   field_decl = build_outer_field_access (qual_wfl, field_decl);
10164                   from_qualified_this = 0;
10165                 }
10166
10167               /* This is the decl found and eventually the next one to
10168                  search from */
10169               decl = field_decl;
10170             }
10171           from_type = 0;
10172           type = QUAL_DECL_TYPE (decl);
10173
10174           /* Sneak preview. If decl is qualified by a `new', report
10175              the error here to be accurate on the peculiar construct */
10176           if (TREE_CHAIN (q)
10177               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10178               && !JREFERENCE_TYPE_P (type))
10179             {
10180               parse_error_context (qual_wfl, "Attempt to reference field %<new%> in a %qs",
10181                                    lang_printable_name (type, 0));
10182               return 1;
10183             }
10184         }
10185       /* `q' might have changed due to a after package resolution
10186          re-qualification */
10187       if (!q)
10188         break;
10189     }
10190   *found_decl = decl;
10191   return 0;
10192 }
10193
10194 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10195    can't be accessed from REFERENCE (a record type). If MEMBER
10196    features a protected access, we then use WHERE which, if non null,
10197    holds the type of MEMBER's access that is checked against
10198    6.6.2.1. This function should be used when decl is a field or a
10199    method.  */
10200
10201 static int
10202 not_accessible_p (tree reference, tree member, tree where, int from_super)
10203 {
10204   int access_flag = get_access_flags_from_decl (member);
10205   bool is_static = false;
10206
10207   if (TREE_CODE (member) == FIELD_DECL ||
10208       TREE_CODE (member) == VAR_DECL)
10209     is_static = FIELD_STATIC (member);
10210   else
10211     is_static = METHOD_STATIC (member);
10212
10213   /* Access always granted for members declared public */
10214   if (access_flag & ACC_PUBLIC)
10215     return 0;
10216
10217   /* Check access on protected members */
10218   if (access_flag & ACC_PROTECTED)
10219     {
10220       /* Access granted if it occurs from within the package
10221          containing the class in which the protected member is
10222          declared */
10223       if (class_in_current_package (DECL_CONTEXT (member)))
10224         return 0;
10225
10226       /* If accessed with the form `super.member', then access is granted */
10227       if (from_super)
10228         return 0;
10229
10230       /* If WHERE is active, access was made through a qualifier. For
10231          non-static members, access is granted if the type of the qualifier
10232          is or is a sublass of the type the access is made from (6.6.2.1.)  */
10233       if (where && !is_static)
10234         {
10235           while (reference)
10236             {
10237               if (inherits_from_p (where, reference))
10238                 return 0;
10239               if (INNER_CLASS_TYPE_P (reference))
10240                 reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10241               else
10242                 break;
10243             }
10244           return 1;
10245         }
10246
10247       /* Otherwise, access is granted if occurring from within the class
10248          where member is declared, or a subclass of it.  */
10249       while (reference)
10250         {
10251           if (inherits_from_p (reference, DECL_CONTEXT (member)))
10252             return 0;
10253           if (INNER_CLASS_TYPE_P (reference))
10254             reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10255           else
10256             break;
10257         }
10258       return 1;
10259     }
10260
10261   /* Check access on private members. Access is granted only if it
10262      occurs from within the class in which it is declared -- that does
10263      it for innerclasses too. */
10264   if (access_flag & ACC_PRIVATE)
10265     {
10266       if (reference == DECL_CONTEXT (member) ||
10267           common_enclosing_context_p (DECL_CONTEXT (member), reference))
10268         return 0;
10269       return 1;
10270     }
10271
10272   /* Default access is permitted only when occurring from within the
10273      package in which the context (MEMBER) is declared.  */
10274   return !class_in_current_package (DECL_CONTEXT (member));
10275 }
10276
10277 /* Test deprecated decl access.  */
10278 static void
10279 check_deprecation (tree wfl, tree decl)
10280 {
10281   const char *file;
10282   tree elt;
10283
10284   if (! warn_deprecated)
10285     return;
10286
10287   /* We want to look at the element type of arrays here, so we strip
10288      all surrounding array types.  */
10289   if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10290     {
10291       elt = TREE_TYPE (decl);
10292       while (TYPE_ARRAY_P (elt))
10293         elt = TYPE_ARRAY_ELEMENT (elt);
10294       /* We'll end up with a pointer type, so we use TREE_TYPE to go
10295          to the record.  */
10296       decl = TYPE_NAME (TREE_TYPE (elt));
10297     }
10298   file = DECL_SOURCE_FILE (decl);
10299
10300   /* Complain if the field is deprecated and the file it was defined
10301      in isn't compiled at the same time the file which contains its
10302      use is */
10303   if (DECL_DEPRECATED (decl)
10304       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10305     {
10306       const char *the;
10307       switch (TREE_CODE (decl))
10308         {
10309         case FUNCTION_DECL:
10310           the = "method";
10311           break;
10312         case FIELD_DECL:
10313         case VAR_DECL:
10314           the = "field";
10315           break;
10316         case TYPE_DECL:
10317           parse_warning_context (wfl, "The class %qs has been deprecated",
10318                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10319           return;
10320         default:
10321           abort ();
10322         }
10323       /* Don't issue a message if the context as been deprecated as a
10324          whole. */
10325       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10326         parse_warning_context
10327           (wfl, "The %s %qs in class %qs has been deprecated",
10328            the, lang_printable_name (decl, 0),
10329            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10330     }
10331 }
10332
10333 /* Returns 1 if class was declared in the current package, 0 otherwise */
10334
10335 static GTY(()) tree cicp_cache;
10336 static int
10337 class_in_current_package (tree class)
10338 {
10339   int qualified_flag;
10340   tree left;
10341
10342   if (cicp_cache == class)
10343     return 1;
10344
10345   qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
10346
10347   /* If the current package is empty and the name of CLASS is
10348      qualified, class isn't in the current package.  If there is a
10349      current package and the name of the CLASS is not qualified, class
10350      isn't in the current package */
10351   if ((!ctxp->package && qualified_flag) || (ctxp->package && !qualified_flag))
10352     return 0;
10353
10354   /* If there is not package and the name of CLASS isn't qualified,
10355      they belong to the same unnamed package */
10356   if (!ctxp->package && !qualified_flag)
10357     return 1;
10358
10359   /* Compare the left part of the name of CLASS with the package name */
10360   split_qualified_name (&left, NULL, DECL_NAME (TYPE_NAME (class)));
10361   if (ctxp->package == left)
10362     {
10363       cicp_cache = class;
10364       return 1;
10365     }
10366   return 0;
10367 }
10368
10369 /* This function may generate code to access DECL from WHERE. This is
10370    done only if certain conditions meet.  */
10371
10372 static tree
10373 maybe_access_field (tree decl, tree where, tree type)
10374 {
10375   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10376       && !FIELD_STATIC (decl))
10377     decl = build_field_ref (where ? where : current_this,
10378                             (type ? type : DECL_CONTEXT (decl)),
10379                             DECL_NAME (decl));
10380   return decl;
10381 }
10382
10383 /* Build a method invocation, by patching PATCH. If non NULL
10384    and according to the situation, PRIMARY and WHERE may be
10385    used. IS_STATIC is set to 1 if the invoked function is static. */
10386
10387 static tree
10388 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10389                          int *is_static, tree *ret_decl)
10390 {
10391   tree wfl = TREE_OPERAND (patch, 0);
10392   tree args = TREE_OPERAND (patch, 1);
10393   tree name = EXPR_WFL_NODE (wfl);
10394   tree list;
10395   int is_static_flag = 0;
10396   int is_super_init = 0;
10397   tree this_arg = NULL_TREE;
10398   int is_array_clone_call = 0;
10399
10400   /* Should be overridden if everything goes well. Otherwise, if
10401      something fails, it should keep this value. It stop the
10402      evaluation of a bogus assignment. See java_complete_tree,
10403      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10404      evaluating an assignment */
10405   TREE_TYPE (patch) = error_mark_node;
10406
10407   /* Since lookup functions are messing with line numbers, save the
10408      context now.  */
10409   java_parser_context_save_global ();
10410
10411   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10412
10413   /* Resolution of qualified name, excluding constructors */
10414   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10415     {
10416       tree identifier, identifier_wfl, type, resolved;
10417       /* Extract the last IDENTIFIER of the qualified
10418          expression. This is a wfl and we will use it's location
10419          data during error report. */
10420       identifier_wfl = cut_identifier_in_qualified (wfl);
10421       identifier = EXPR_WFL_NODE (identifier_wfl);
10422
10423       /* Given the context, IDENTIFIER is syntactically qualified
10424          as a MethodName. We need to qualify what's before */
10425       qualify_ambiguous_name (wfl);
10426       resolved = resolve_field_access (wfl, NULL, NULL);
10427
10428       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10429          && FIELD_FINAL (resolved)
10430          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10431          && !flag_emit_class_files)
10432        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10433
10434       if (resolved == error_mark_node)
10435         PATCH_METHOD_RETURN_ERROR ();
10436
10437       type = GET_SKIP_TYPE (resolved);
10438       resolve_and_layout (type, NULL_TREE);
10439
10440       if (JPRIMITIVE_TYPE_P (type))
10441         {
10442           parse_error_context
10443             (identifier_wfl,
10444              "Can't invoke a method on primitive type %qs",
10445              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10446           PATCH_METHOD_RETURN_ERROR ();
10447         }
10448
10449       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10450       args = nreverse (args);
10451
10452       /* We're resolving a call from a type */
10453       if (TREE_CODE (resolved) == TYPE_DECL)
10454         {
10455           if (CLASS_INTERFACE (resolved))
10456             {
10457               parse_error_context
10458                 (identifier_wfl,
10459                 "Can't make static reference to method %qs in interface %qs",
10460                  IDENTIFIER_POINTER (identifier),
10461                  IDENTIFIER_POINTER (name));
10462               PATCH_METHOD_RETURN_ERROR ();
10463             }
10464           if (list && !METHOD_STATIC (list))
10465             {
10466               char *fct_name = xstrdup (lang_printable_name (list, 2));
10467               parse_error_context
10468                 (identifier_wfl,
10469                  "Can't make static reference to method %<%s %s%> in class %qs",
10470                  lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10471                  fct_name, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10472               free (fct_name);
10473               PATCH_METHOD_RETURN_ERROR ();
10474             }
10475         }
10476       else
10477         this_arg = primary = resolved;
10478
10479       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10480         is_array_clone_call = 1;
10481
10482       /* IDENTIFIER_WFL will be used to report any problem further */
10483       wfl = identifier_wfl;
10484     }
10485   /* Resolution of simple names, names generated after a primary: or
10486      constructors */
10487   else
10488     {
10489       tree class_to_search = NULL_TREE;
10490       int lc;                   /* Looking for Constructor */
10491
10492       /* We search constructor in their target class */
10493       if (CALL_CONSTRUCTOR_P (patch))
10494         {
10495           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10496             class_to_search = EXPR_WFL_NODE (wfl);
10497           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10498                    this_identifier_node)
10499             class_to_search = NULL_TREE;
10500           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10501                    super_identifier_node)
10502             {
10503               is_super_init = 1;
10504               if (CLASSTYPE_SUPER (current_class))
10505                 class_to_search =
10506                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10507               else
10508                 {
10509                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10510                   PATCH_METHOD_RETURN_ERROR ();
10511                 }
10512             }
10513
10514           /* Class to search is NULL if we're searching the current one */
10515           if (class_to_search)
10516             {
10517               class_to_search = resolve_and_layout (class_to_search, wfl);
10518
10519               if (!class_to_search)
10520                 {
10521                   parse_error_context
10522                     (wfl, "Class %qs not found in type declaration",
10523                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10524                   PATCH_METHOD_RETURN_ERROR ();
10525                 }
10526
10527               /* Can't instantiate an abstract class, but we can
10528                  invoke it's constructor. It's use within the `new'
10529                  context is denied here. */
10530               if (CLASS_ABSTRACT (class_to_search)
10531                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10532                 {
10533                   parse_error_context
10534                     (wfl, "Class %qs is an abstract class. It can't be instantiated",
10535                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10536                   PATCH_METHOD_RETURN_ERROR ();
10537                 }
10538
10539               class_to_search = TREE_TYPE (class_to_search);
10540             }
10541           else
10542             class_to_search = current_class;
10543           lc = 1;
10544         }
10545       /* This is a regular search in the local class, unless an
10546          alternate class is specified. */
10547       else
10548         {
10549           if (where != NULL_TREE)
10550             class_to_search = where;
10551           else if (QUALIFIED_P (name))
10552             class_to_search = current_class;
10553           else
10554             {
10555               class_to_search = current_class;
10556
10557               for (;;)
10558                 {
10559                   if (has_method (class_to_search, name))
10560                     break;
10561                   if (! INNER_CLASS_TYPE_P (class_to_search))
10562                     {
10563                       parse_error_context (wfl,
10564                                            "No method named %qs in scope",
10565                                            IDENTIFIER_POINTER (name));
10566                       PATCH_METHOD_RETURN_ERROR ();
10567                     }
10568                   class_to_search
10569                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10570                 }
10571             }
10572           lc = 0;
10573         }
10574
10575       /* NAME is a simple identifier or comes from a primary. Search
10576          in the class whose declaration contain the method being
10577          invoked. */
10578       resolve_and_layout (class_to_search, NULL_TREE);
10579
10580       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10581       /* Don't continue if no method were found, as the next statement
10582          can't be executed then. */
10583       if (!list)
10584         PATCH_METHOD_RETURN_ERROR ();
10585
10586       if (TYPE_ARRAY_P (class_to_search)
10587           && DECL_NAME (list) == get_identifier ("clone"))
10588         is_array_clone_call = 1;
10589
10590       /* Check for static reference if non static methods */
10591       if (check_for_static_method_reference (wfl, patch, list,
10592                                              class_to_search, primary))
10593         PATCH_METHOD_RETURN_ERROR ();
10594
10595       /* Check for inner classes creation from illegal contexts */
10596       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10597                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10598           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10599           && !DECL_INIT_P (current_function_decl))
10600         {
10601           parse_error_context
10602             (wfl, "No enclosing instance for inner class %qs is in scope%s",
10603              lang_printable_name (class_to_search, 0),
10604              (!current_this ? "" :
10605               "; an explicit one must be provided when creating this inner class"));
10606           PATCH_METHOD_RETURN_ERROR ();
10607         }
10608
10609       /* Non static methods are called with the current object extra
10610          argument. If patch a `new TYPE()', the argument is the value
10611          returned by the object allocator. If method is resolved as a
10612          primary, use the primary otherwise use the current THIS. */
10613       args = nreverse (args);
10614       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10615         {
10616           this_arg = primary ? primary : current_this;
10617
10618           /* If we're using an access method, things are different.
10619              There are two family of cases:
10620
10621              1) We're not generating bytecodes:
10622
10623              - LIST is non static. It's invocation is transformed from
10624                x(a1,...,an) into this$<n>.x(a1,....an).
10625              - LIST is static. It's invocation is transformed from
10626                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10627
10628              2) We're generating bytecodes:
10629
10630              - LIST is non static. It's invocation is transformed from
10631                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10632              - LIST is static. It's invocation is transformed from
10633                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10634
10635              Of course, this$<n> can be arbitrarily complex, ranging from
10636              this$0 (the immediate outer context) to
10637              access$0(access$0(...(this$0))).
10638
10639              maybe_use_access_method returns a nonzero value if the
10640              this_arg has to be moved into the (then generated) stub
10641              argument list. In the meantime, the selected function
10642              might have be replaced by a generated stub. */
10643           if (!primary &&
10644               maybe_use_access_method (is_super_init, &list, &this_arg))
10645             {
10646               args = tree_cons (NULL_TREE, this_arg, args);
10647               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10648             }
10649         }
10650     }
10651
10652   /* Merge point of all resolution schemes. If we have nothing, this
10653      is an error, already signaled */
10654   if (!list)
10655     PATCH_METHOD_RETURN_ERROR ();
10656
10657   /* Check accessibility, position the is_static flag, build and
10658      return the call */
10659   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10660                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10661                          NULL_TREE), from_super)
10662       /* Calls to clone() on array types are permitted as a special-case. */
10663       && !is_array_clone_call)
10664     {
10665       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10666       const char *const access =
10667         accessibility_string (get_access_flags_from_decl (list));
10668       const char *const klass =
10669         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10670       const char *const refklass =
10671         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10672       const char *const what = (DECL_CONSTRUCTOR_P (list)
10673                                 ? "constructor" : "method");
10674       parse_error_context (wfl,
10675                            "Can't access %s %s %<%s.%s%> from %qs",
10676                            access, what, klass, fct_name, refklass);
10677       PATCH_METHOD_RETURN_ERROR ();
10678     }
10679
10680   /* Deprecation check: check whether the method being invoked or the
10681      instance-being-created's type are deprecated.  */
10682   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10683     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10684   check_deprecation (wfl, list);
10685
10686   /* If invoking a innerclass constructor, there are hidden parameters
10687      to pass */
10688   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10689       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10690     {
10691       /* And make sure we add the accessed local variables to be saved
10692          in field aliases. */
10693       args = build_alias_initializer_parameter_list
10694         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10695
10696       /* Secretly pass the current_this/primary as a second argument */
10697       if (primary || current_this)
10698         {
10699           tree extra_arg;
10700           tree this_type = (current_this ?
10701                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10702           /* Method's (list) enclosing context */
10703           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10704           /* If we have a primary, use it. */
10705           if (primary)
10706             extra_arg = primary;
10707           /* The current `this' is an inner class but isn't a direct
10708              enclosing context for the inner class we're trying to
10709              create. Build an access to the proper enclosing context
10710              and use it. */
10711           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10712                    && this_type != TREE_TYPE (mec))
10713             {
10714
10715               extra_arg = build_access_to_thisn (current_class,
10716                                                  TREE_TYPE (mec), 0);
10717               extra_arg = java_complete_tree (extra_arg);
10718             }
10719           /* Otherwise, just use the current `this' as an enclosing
10720              context. */
10721           else
10722             extra_arg = current_this;
10723           args = tree_cons (NULL_TREE, extra_arg, args);
10724         }
10725       else
10726         args = tree_cons (NULL_TREE, integer_zero_node, args);
10727     }
10728
10729   /* This handles the situation where a constructor invocation needs
10730      to have an enclosing context passed as a second parameter (the
10731      constructor is one of an inner class). */
10732   if ((is_super_init ||
10733        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10734       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10735     {
10736       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10737       tree extra_arg =
10738         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10739       extra_arg = java_complete_tree (extra_arg);
10740       args = tree_cons (NULL_TREE, extra_arg, args);
10741     }
10742
10743   is_static_flag = METHOD_STATIC (list);
10744   if (! is_static_flag && this_arg != NULL_TREE)
10745     args = tree_cons (NULL_TREE, this_arg, args);
10746
10747   /* In the context of an explicit constructor invocation, we can't
10748      invoke any method relying on `this'. Exceptions are: we're
10749      invoking a static function, primary exists and is not the current
10750      this, we're creating a new object. */
10751   if (ctxp->explicit_constructor_p
10752       && !is_static_flag
10753       && (!primary || primary == current_this)
10754       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10755     {
10756       parse_error_context (wfl, "Can't reference %<this%> before the superclass constructor has been called");
10757       PATCH_METHOD_RETURN_ERROR ();
10758     }
10759   java_parser_context_restore_global ();
10760   if (is_static)
10761     *is_static = is_static_flag;
10762   /* Sometimes, we want the decl of the selected method. Such as for
10763      EH checking */
10764   if (ret_decl)
10765     *ret_decl = list;
10766   patch = patch_invoke (patch, list, args);
10767
10768   /* Now is a good time to insert the call to finit$ */
10769   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10770     {
10771       tree finit_parms, finit_call;
10772
10773       /* Prepare to pass hidden parameters to finit$, if any. */
10774       finit_parms = build_alias_initializer_parameter_list
10775         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10776
10777       finit_call =
10778         build_method_invocation (build_wfl_node (finit_identifier_node),
10779                                  finit_parms);
10780
10781       /* Generate the code used to initialize fields declared with an
10782          initialization statement and build a compound statement along
10783          with the super constructor invocation. */
10784       CAN_COMPLETE_NORMALLY (patch) = 1;
10785       patch = build2 (COMPOUND_EXPR, void_type_node, patch,
10786                       java_complete_tree (finit_call));
10787     }
10788   return patch;
10789 }
10790
10791 /* Check that we're not trying to do a static reference to a method in
10792    non static method. Return 1 if it's the case, 0 otherwise. */
10793
10794 static int
10795 check_for_static_method_reference (tree wfl, tree node, tree method,
10796                                    tree where, tree primary)
10797 {
10798   if (METHOD_STATIC (current_function_decl)
10799       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10800     {
10801       char *fct_name = xstrdup (lang_printable_name (method, 0));
10802       parse_error_context
10803         (wfl, "Can't make static reference to method %<%s %s%> in class %qs",
10804          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10805          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10806       free (fct_name);
10807       return 1;
10808     }
10809   return 0;
10810 }
10811
10812 /* Fix the invocation of *MDECL if necessary in the case of a
10813    invocation from an inner class. *THIS_ARG might be modified
10814    appropriately and an alternative access to *MDECL might be
10815    returned.  */
10816
10817 static int
10818 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10819 {
10820   tree ctx;
10821   tree md = *mdecl, ta = *this_arg;
10822   int to_return = 0;
10823   int non_static_context = !METHOD_STATIC (md);
10824
10825   if (is_super_init
10826       || DECL_CONTEXT (md) == current_class
10827       || !PURE_INNER_CLASS_TYPE_P (current_class)
10828       || DECL_FINIT_P (md)
10829       || DECL_INSTINIT_P (md))
10830     return 0;
10831
10832   /* If we're calling a method found in an enclosing class, generate
10833      what it takes to retrieve the right this. Don't do that if we're
10834      invoking a static method. Note that if MD's type is unrelated to
10835      CURRENT_CLASS, then the current this can be used. */
10836
10837   if (non_static_context && DECL_CONTEXT (md) != object_type_node)
10838     {
10839       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10840       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10841         {
10842           ta = build_current_thisn (current_class);
10843           ta = build_wfl_node (ta);
10844         }
10845       else
10846         {
10847           tree type = ctx;
10848           while (type)
10849             {
10850               maybe_build_thisn_access_method (type);
10851               if (inherits_from_p (type, DECL_CONTEXT (md)))
10852                 {
10853                   ta = build_access_to_thisn (ctx, type, 0);
10854                   break;
10855                 }
10856               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10857                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10858             }
10859         }
10860       ta = java_complete_tree (ta);
10861     }
10862
10863   /* We might have to use an access method to get to MD. We can
10864      break the method access rule as far as we're not generating
10865      bytecode */
10866   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10867     {
10868       md = build_outer_method_access_method (md);
10869       to_return = 1;
10870     }
10871
10872   *mdecl = md;
10873   *this_arg = ta;
10874
10875   /* Returning a nonzero value indicates we were doing a non static
10876      method invocation that is now a static invocation. It will have
10877      callee displace `this' to insert it in the regular argument
10878      list. */
10879   return (non_static_context && to_return);
10880 }
10881
10882 /* Patch an invoke expression METHOD and ARGS, based on its invocation
10883    mode.  */
10884
10885 static tree
10886 patch_invoke (tree patch, tree method, tree args)
10887 {
10888   tree dtable, func;
10889   tree original_call, t, ta;
10890   tree check = NULL_TREE;
10891
10892   /* Last step for args: convert build-in types. If we're dealing with
10893      a new TYPE() type call, the first argument to the constructor
10894      isn't found in the incoming argument list, but delivered by
10895      `new' */
10896   t = TYPE_ARG_TYPES (TREE_TYPE (method));
10897   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10898     t = TREE_CHAIN (t);
10899   for (ta = args; t != end_params_node && ta;
10900        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
10901     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
10902         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
10903       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
10904
10905   /* Resolve unresolved returned type issues */
10906   t = TREE_TYPE (TREE_TYPE (method));
10907   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
10908     resolve_and_layout (TREE_TYPE (t), NULL);
10909
10910   if (flag_emit_class_files)
10911     func = method;
10912   else
10913     {
10914       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
10915         {
10916         case INVOKE_VIRTUAL:
10917           dtable = invoke_build_dtable (0, args);
10918           func = build_invokevirtual (dtable, method);
10919           break;
10920
10921         case INVOKE_NONVIRTUAL:
10922           /* If the object for the method call is null, we throw an
10923              exception.  We don't do this if the object is the current
10924              method's `this'.  In other cases we just rely on an
10925              optimization pass to eliminate redundant checks.  */
10926           if (TREE_VALUE (args) != current_this)
10927             {
10928               /* We use a save_expr here to make sure we only evaluate
10929                  the new `self' expression once.  */
10930               tree save_arg = save_expr (TREE_VALUE (args));
10931               TREE_VALUE (args) = save_arg;
10932               check = java_check_reference (save_arg, 1);
10933             }
10934           /* Fall through.  */
10935
10936         case INVOKE_SUPER:
10937         case INVOKE_STATIC:
10938           {
10939             tree signature = build_java_signature (TREE_TYPE (method));
10940             func = build_known_method_ref (method, TREE_TYPE (method),
10941                                            DECL_CONTEXT (method),
10942                                            signature, args);
10943           }
10944           break;
10945
10946         case INVOKE_INTERFACE:
10947           dtable = invoke_build_dtable (1, args);
10948           func = build_invokeinterface (dtable, method);
10949           break;
10950
10951         default:
10952           abort ();
10953         }
10954
10955       /* Ensure self_type is initialized, (invokestatic). FIXME */
10956       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
10957     }
10958
10959   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
10960   TREE_OPERAND (patch, 0) = func;
10961   TREE_OPERAND (patch, 1) = args;
10962   patch = check_for_builtin (method, patch);
10963   original_call = patch;
10964
10965   /* We're processing a `new TYPE ()' form. New is called and its
10966      returned value is the first argument to the constructor. We build
10967      a COMPOUND_EXPR and use saved expression so that the overall NEW
10968      expression value is a pointer to a newly created and initialized
10969      class. */
10970   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
10971     {
10972       tree class = DECL_CONTEXT (method);
10973       tree c1, saved_new, new;
10974       tree alloc_node;
10975
10976       if (flag_emit_class_files)
10977         {
10978           TREE_TYPE (patch) = build_pointer_type (class);
10979           return patch;
10980         }
10981       if (!TYPE_SIZE (class))
10982         safe_layout_class (class);
10983       alloc_node =
10984         (class_has_finalize_method (class) ? alloc_object_node
10985                                            : alloc_no_finalizer_node);
10986       new = build3 (CALL_EXPR, promote_type (class),
10987                     build_address_of (alloc_node),
10988                     build_tree_list (NULL_TREE, build_class_ref (class)),
10989                     NULL_TREE);
10990       saved_new = save_expr (new);
10991       c1 = build_tree_list (NULL_TREE, saved_new);
10992       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
10993       TREE_OPERAND (original_call, 1) = c1;
10994       TREE_SET_CODE (original_call, CALL_EXPR);
10995       patch = build2 (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
10996     }
10997
10998   /* If CHECK is set, then we are building a check to see if the object
10999      is NULL.  */
11000   if (check != NULL_TREE)
11001     {
11002       /* We have to call force_evaluation_order now because creating a
11003          COMPOUND_EXPR wraps the arg list in a way that makes it
11004          unrecognizable by force_evaluation_order later.  Yuk.  */
11005       patch = build2 (COMPOUND_EXPR, TREE_TYPE (patch), check,
11006                       force_evaluation_order (patch));
11007       TREE_SIDE_EFFECTS (patch) = 1;
11008     }
11009
11010   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
11011      put it as the first expression of a COMPOUND_EXPR. The second
11012      expression being an empty statement to be later patched if
11013      necessary. We remember a TREE_LIST (the PURPOSE is the method,
11014      the VALUE is the compound) in a hashtable and return a
11015      COMPOUND_EXPR built so that the result of the evaluation of the
11016      original PATCH node is returned. */
11017   if (STATIC_CLASS_INIT_OPT_P ()
11018       && current_function_decl && METHOD_STATIC (method))
11019     {
11020       tree list;
11021       tree fndecl = current_function_decl;
11022       /* We have to call force_evaluation_order now because creating a
11023          COMPOUND_EXPR wraps the arg list in a way that makes it
11024          unrecognizable by force_evaluation_order later.  Yuk.  */
11025       tree save = force_evaluation_order (patch);
11026       tree type = TREE_TYPE (patch);
11027
11028       patch = build2 (COMPOUND_EXPR, type, save, build_java_empty_stmt ());
11029       list = tree_cons (method, patch,
11030                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
11031
11032       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
11033
11034       patch = build2 (COMPOUND_EXPR, type, patch, save);
11035     }
11036
11037   return patch;
11038 }
11039
11040 static int
11041 invocation_mode (tree method, int super)
11042 {
11043   int access = get_access_flags_from_decl (method);
11044
11045   if (super)
11046     return INVOKE_SUPER;
11047
11048   if (access & ACC_STATIC)
11049     return INVOKE_STATIC;
11050
11051   /* We have to look for a constructor before we handle nonvirtual
11052      calls; otherwise the constructor will look nonvirtual.  */
11053   if (DECL_CONSTRUCTOR_P (method))
11054     return INVOKE_STATIC;
11055
11056   if (access & ACC_PRIVATE)
11057     return INVOKE_NONVIRTUAL;
11058
11059   /* Binary compatibility: just because it's final today, that doesn't
11060      mean it'll be final tomorrow.  */
11061   if (! flag_indirect_dispatch
11062       || DECL_CONTEXT (method) == object_type_node)
11063     {
11064       if (access & ACC_FINAL)
11065         return INVOKE_NONVIRTUAL;
11066
11067       if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
11068         return INVOKE_NONVIRTUAL;
11069     }
11070
11071   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
11072     return INVOKE_INTERFACE;
11073
11074   return INVOKE_VIRTUAL;
11075 }
11076
11077 /* Retrieve a refined list of matching methods. It covers the step
11078    15.11.2 (Compile-Time Step 2) */
11079
11080 static tree
11081 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
11082 {
11083   tree atl = end_params_node;           /* Arg Type List */
11084   tree method, signature, list, node;
11085   const char *candidates;               /* Used for error report */
11086   char *dup;
11087
11088   /* Fix the arguments */
11089   for (node = arg_list; node; node = TREE_CHAIN (node))
11090     {
11091       tree current_arg = TREE_TYPE (TREE_VALUE (node));
11092       /* Non primitive type may have to be resolved */
11093       if (!JPRIMITIVE_TYPE_P (current_arg))
11094         resolve_and_layout (current_arg, NULL_TREE);
11095       /* And promoted */
11096       if (TREE_CODE (current_arg) == RECORD_TYPE)
11097         current_arg = promote_type (current_arg);
11098       atl = tree_cons (NULL_TREE, current_arg, atl);
11099     }
11100
11101   /* Presto. If we're dealing with an anonymous class and a
11102      constructor call, generate the right constructor now, since we
11103      know the arguments' types. */
11104
11105   if (lc && ANONYMOUS_CLASS_P (class))
11106     {
11107       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
11108       /* The anonymous class may have already been laid out, so make sure
11109          the new constructor is laid out here.  */
11110       layout_class_method (class, CLASSTYPE_SUPER (class), mdecl, NULL_TREE);
11111     }
11112
11113   /* Find all candidates and then refine the list, searching for the
11114      most specific method. */
11115   list = find_applicable_accessible_methods_list (lc, class, name, atl);
11116   list = find_most_specific_methods_list (list);
11117   if (list && !TREE_CHAIN (list))
11118     return TREE_VALUE (list);
11119
11120   /* Issue an error. List candidates if any. Candidates are listed
11121      only if accessible (non accessible methods may end-up here for
11122      the sake of a better error report). */
11123   candidates = NULL;
11124   if (list)
11125     {
11126       tree current;
11127       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
11128       for (current = list; current; current = TREE_CHAIN (current))
11129         {
11130           tree cm = TREE_VALUE (current);
11131           char string [4096];
11132           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
11133             continue;
11134           sprintf
11135             (string, "  '%s' in '%s'%s",
11136              get_printable_method_name (cm),
11137              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
11138              (TREE_CHAIN (current) ? "\n" : ""));
11139           obstack_grow (&temporary_obstack, string, strlen (string));
11140         }
11141       obstack_1grow (&temporary_obstack, '\0');
11142       candidates = obstack_finish (&temporary_obstack);
11143     }
11144   /* Issue the error message */
11145   method = make_node (FUNCTION_TYPE);
11146   TYPE_ARG_TYPES (method) = atl;
11147   signature = build_java_argument_signature (method);
11148   dup = xstrdup (lang_printable_name (class, 0));
11149   parse_error_context (cl, "Can't find %s %<%s(%s)%> in type %qs%s",
11150                        (lc ? "constructor" : "method"),
11151                        (lc ? dup : IDENTIFIER_POINTER (name)),
11152                        IDENTIFIER_POINTER (signature), dup,
11153                        (candidates ? candidates : ""));
11154   free (dup);
11155   return NULL_TREE;
11156 }
11157
11158 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
11159    when we're looking for a constructor. */
11160
11161 static tree
11162 find_applicable_accessible_methods_list (int lc, tree class, tree name,
11163                                          tree arglist)
11164 {
11165   static htab_t searched_classes;
11166   static int search_not_done = 0;
11167   tree list = NULL_TREE, all_list = NULL_TREE;
11168   tree base_binfo;
11169   int i;
11170
11171   /* Check the hash table to determine if this class has been searched
11172      already. */
11173   if (searched_classes)
11174     {
11175       if (htab_find (searched_classes, class) != NULL)
11176         return NULL;
11177     }
11178   else
11179     {
11180       searched_classes = htab_create (10, htab_hash_pointer,
11181                                       htab_eq_pointer, NULL);
11182     }
11183
11184   search_not_done++;
11185   *htab_find_slot (searched_classes, class, INSERT) = class;
11186
11187   if (!CLASS_LOADED_P (class))
11188     {
11189       load_class (class, 1);
11190       safe_layout_class (class);
11191     }
11192
11193   /* Search interfaces */
11194   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11195       && CLASS_INTERFACE (TYPE_NAME (class)))
11196     {
11197       search_applicable_methods_list (lc, TYPE_METHODS (class),
11198                                       name, arglist, &list, &all_list);
11199       for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
11200         {
11201           tree t = BINFO_TYPE (base_binfo);
11202           tree rlist;
11203
11204           rlist = find_applicable_accessible_methods_list (lc,  t, name,
11205                                                            arglist);
11206           list = chainon (rlist, list);
11207         }
11208     }
11209   /* Search classes */
11210   else
11211     {
11212       search_applicable_methods_list (lc, TYPE_METHODS (class),
11213                                       name, arglist, &list, &all_list);
11214
11215       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11216          that we only search in class. Note that we should have found
11217          something at this point. */
11218       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11219         {
11220           lc = 1;
11221           if (!list)
11222             abort ();
11223         }
11224
11225       /* We must search all interfaces of this class */
11226       if (!lc)
11227         {
11228           for (i = 1;
11229                BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
11230             {
11231               tree t = BINFO_TYPE (base_binfo);
11232               if (t != object_type_node)
11233                 {
11234                   tree rlist
11235                     = find_applicable_accessible_methods_list (lc, t,
11236                                                                name, arglist);
11237                   list = chainon (rlist, list);
11238                 }
11239             }
11240         }
11241
11242       /* Search superclass */
11243       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11244         {
11245           tree rlist;
11246           class = CLASSTYPE_SUPER (class);
11247           rlist = find_applicable_accessible_methods_list (lc, class,
11248                                                            name, arglist);
11249           list = chainon (rlist, list);
11250         }
11251     }
11252
11253   search_not_done--;
11254
11255   /* We're done. Reset the searched classes list and finally search
11256      java.lang.Object if it wasn't searched already. */
11257   if (!search_not_done)
11258     {
11259       if (!lc
11260           && TYPE_METHODS (object_type_node)
11261           && htab_find (searched_classes, object_type_node) == NULL)
11262         {
11263           search_applicable_methods_list (lc,
11264                                           TYPE_METHODS (object_type_node),
11265                                           name, arglist, &list, &all_list);
11266         }
11267       htab_delete (searched_classes);
11268       searched_classes = NULL;
11269     }
11270
11271   /* Either return the list obtained or all selected (but
11272      inaccessible) methods for better error report. */
11273   return (!list ? all_list : list);
11274 }
11275
11276 /* Effectively search for the appropriate method in method */
11277
11278 static void
11279 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11280                                 tree *list, tree *all_list)
11281 {
11282   for (; method; method = TREE_CHAIN (method))
11283     {
11284       /* When dealing with constructor, stop here, otherwise search
11285          other classes */
11286       if (lc && !DECL_CONSTRUCTOR_P (method))
11287         continue;
11288       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11289                        || (DECL_NAME (method) != name)))
11290         continue;
11291
11292       if (argument_types_convertible (method, arglist))
11293         {
11294           /* Retain accessible methods only */
11295           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11296                                  method, NULL_TREE, 0))
11297             *list = tree_cons (NULL_TREE, method, *list);
11298           else
11299             /* Also retain all selected method here */
11300             *all_list = tree_cons (NULL_TREE, method, *list);
11301         }
11302     }
11303 }
11304
11305 /* 15.11.2.2 Choose the Most Specific Method */
11306
11307 static tree
11308 find_most_specific_methods_list (tree list)
11309 {
11310   int max = 0;
11311   int abstract, candidates;
11312   tree current, new_list = NULL_TREE;
11313   for (current = list; current; current = TREE_CHAIN (current))
11314     {
11315       tree method;
11316       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11317
11318       for (method = list; method; method = TREE_CHAIN (method))
11319         {
11320           tree method_v, current_v;
11321           /* Don't test a method against itself */
11322           if (method == current)
11323             continue;
11324
11325           method_v = TREE_VALUE (method);
11326           current_v = TREE_VALUE (current);
11327
11328           /* Compare arguments and location where methods where declared */
11329           if (argument_types_convertible (method_v, current_v))
11330             {
11331               if (valid_method_invocation_conversion_p
11332                   (DECL_CONTEXT (method_v), DECL_CONTEXT (current_v))
11333                   || (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v))
11334                       && enclosing_context_p (DECL_CONTEXT (method_v),
11335                                               DECL_CONTEXT (current_v))))
11336                 {
11337                   int v = (DECL_SPECIFIC_COUNT (current_v) +=
11338                     (INNER_CLASS_TYPE_P (DECL_CONTEXT (current_v)) ? 2 : 1));
11339                   max = (v > max ? v : max);
11340                 }
11341             }
11342         }
11343     }
11344
11345   /* Review the list and select the maximally specific methods */
11346   for (current = list, abstract = -1, candidates = -1;
11347        current; current = TREE_CHAIN (current))
11348     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11349       {
11350         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11351         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11352         candidates++;
11353       }
11354
11355   /* If we have several and they're all abstract, just pick the
11356      closest one. */
11357   if (candidates > 0 && candidates == abstract)
11358     {
11359       /* FIXME: merge the throws clauses.  There is no convenient way
11360          to do this in gcj right now, since ideally we'd like to
11361          introduce a new METHOD_DECL here, but that is really not
11362          possible.  */
11363       new_list = nreverse (new_list);
11364       TREE_CHAIN (new_list) = NULL_TREE;
11365       return new_list;
11366     }
11367
11368   /* We have several (we couldn't find a most specific), all but one
11369      are abstract, we pick the only non abstract one. */
11370   if (candidates > 0 && (candidates == abstract+1))
11371     {
11372       for (current = new_list; current; current = TREE_CHAIN (current))
11373         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11374           {
11375             TREE_CHAIN (current) = NULL_TREE;
11376             new_list = current;
11377           }
11378     }
11379
11380   /* If we can't find one, lower expectations and try to gather multiple
11381      maximally specific methods */
11382   while (!new_list && max)
11383     {
11384       while (--max > 0)
11385         {
11386           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11387             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11388         }
11389     }
11390
11391   return new_list;
11392 }
11393
11394 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11395    converted by method invocation conversion (5.3) to the type of the
11396    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11397    to change less often than M1. */
11398
11399 static GTY(()) tree m2_arg_value;
11400 static GTY(()) tree m2_arg_cache;
11401
11402 static int
11403 argument_types_convertible (tree m1, tree m2_or_arglist)
11404 {
11405   tree m1_arg, m2_arg;
11406
11407   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11408
11409   if (m2_arg_value == m2_or_arglist)
11410     m2_arg = m2_arg_cache;
11411   else
11412     {
11413       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11414          argument types */
11415       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11416         {
11417           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11418           if (!METHOD_STATIC (m2_or_arglist))
11419             m2_arg = TREE_CHAIN (m2_arg);
11420         }
11421       else
11422         m2_arg = m2_or_arglist;
11423
11424       m2_arg_value = m2_or_arglist;
11425       m2_arg_cache = m2_arg;
11426     }
11427
11428   while (m1_arg != end_params_node && m2_arg != end_params_node)
11429     {
11430       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11431       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11432                                                  TREE_VALUE (m2_arg)))
11433         break;
11434       m1_arg = TREE_CHAIN (m1_arg);
11435       m2_arg = TREE_CHAIN (m2_arg);
11436     }
11437   return m1_arg == end_params_node && m2_arg == end_params_node;
11438 }
11439
11440 /* Qualification routines */
11441
11442 /* Given a name x.y.z, look up x locally.  If it's found, save the
11443    decl.  If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11444    so that we later try and load the appropriate classes.  */
11445 static void
11446 qualify_ambiguous_name (tree id)
11447 {
11448   tree name, decl;
11449
11450   /* We inspect the first item of the qualification list.  As a sanity
11451      check, make sure that it is an identfier node.  */
11452   tree qual = EXPR_WFL_QUALIFICATION (id);
11453   tree qual_wfl = QUAL_WFL (qual);
11454
11455   if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11456     return;
11457
11458   name = EXPR_WFL_NODE (qual_wfl);
11459
11460   /* If we don't have an identifier, or we have a 'this' or 'super',
11461      then field access processing is all we need : there is nothing
11462      for us to do.  */
11463   if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11464       name == this_identifier_node ||
11465       name == super_identifier_node)
11466     return;
11467
11468   /* If name appears within the scope of a local variable declaration
11469      or parameter declaration, or is a field within an enclosing
11470      class, then it is an expression name.  Save the decl and let
11471      resolve_field_access do it's work.  */
11472   if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11473       (decl = lookup_field_wrapper (current_class, name)))
11474     {
11475       QUAL_RESOLUTION (qual) = decl;
11476       return;
11477     }
11478
11479   /* If name is a known class name (either declared or imported), mark
11480      us as a type name.  */
11481   if ((decl = resolve_and_layout (name, NULL_TREE)))
11482     {
11483       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11484       QUAL_RESOLUTION (qual) = decl;
11485     }
11486
11487   /* Check here that NAME isn't declared by more than one
11488      type-import-on-demand declaration of the compilation unit
11489      containing NAME. FIXME */
11490
11491   /* We couldn't find a declaration for the name.  Assume for now that
11492      we have a qualified class name that needs to be loaded from an
11493      external class file.  */
11494   else
11495     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11496
11497   /* Propagate the qualification across other components of the
11498      qualified name */
11499   for (qual = TREE_CHAIN (qual); qual;
11500        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11501     {
11502       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11503         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11504     }
11505
11506   /* Store the global qualification for the ambiguous part of ID back
11507      into ID fields */
11508   if (RESOLVE_TYPE_NAME_P (qual_wfl))
11509     RESOLVE_TYPE_NAME_P (id) = 1;
11510   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11511     RESOLVE_PACKAGE_NAME_P (id) = 1;
11512 }
11513
11514 /* Patch tree nodes in a function body. When a BLOCK is found, push
11515    local variable decls if present.
11516    Same as java_complete_lhs, but does resolve static finals to values. */
11517
11518 static tree
11519 java_complete_tree (tree node)
11520 {
11521   node = java_complete_lhs (node);
11522   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11523       && DECL_INITIAL (node) != NULL_TREE)
11524     {
11525       tree value = fold_constant_for_init (node, node);
11526       if (value != NULL_TREE)
11527         return value;
11528     }
11529   return node;
11530 }
11531
11532 static tree
11533 java_stabilize_reference (tree node)
11534 {
11535   if (TREE_CODE (node) == COMPOUND_EXPR)
11536     {
11537       tree op0 = TREE_OPERAND (node, 0);
11538       tree op1 = TREE_OPERAND (node, 1);
11539       TREE_OPERAND (node, 0) = save_expr (op0);
11540       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11541       return node;
11542     }
11543   return stabilize_reference (node);
11544 }
11545
11546 /* Patch tree nodes in a function body. When a BLOCK is found, push
11547    local variable decls if present.
11548    Same as java_complete_tree, but does not resolve static finals to values. */
11549
11550 static tree
11551 java_complete_lhs (tree node)
11552 {
11553   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11554   int flag;
11555
11556   /* CONVERT_EXPR always has its type set, even though it needs to be
11557      worked out. */
11558   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11559     return node;
11560
11561   /* The switch block implements cases processing container nodes
11562      first.  Contained nodes are always written back. Leaves come
11563      next and return a value. */
11564   switch (TREE_CODE (node))
11565     {
11566     case BLOCK:
11567
11568       /* 1- Block section.
11569          Set the local values on decl names so we can identify them
11570          faster when they're referenced. At that stage, identifiers
11571          are legal so we don't check for declaration errors. */
11572       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11573         {
11574           DECL_CONTEXT (cn) = current_function_decl;
11575           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11576         }
11577       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11578           CAN_COMPLETE_NORMALLY (node) = 1;
11579       else
11580         {
11581           tree stmt = BLOCK_EXPR_BODY (node);
11582           tree *ptr;
11583           int error_seen = 0;
11584           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11585             {
11586               /* Re-order from (((A; B); C); ...; Z) to
11587                  (A; (B; (C ; (...; Z)))).
11588                  This makes it easier to scan the statements left-to-right
11589                  without using recursion (which might overflow the stack
11590                  if the block has many statements. */
11591               for (;;)
11592                 {
11593                   tree left = TREE_OPERAND (stmt, 0);
11594                   if (TREE_CODE (left) != COMPOUND_EXPR)
11595                     break;
11596                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11597                   TREE_OPERAND (left, 1) = stmt;
11598                   stmt = left;
11599                 }
11600               BLOCK_EXPR_BODY (node) = stmt;
11601             }
11602
11603           /* Now do the actual complete, without deep recursion for
11604              long blocks. */
11605           ptr = &BLOCK_EXPR_BODY (node);
11606           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11607                  && !IS_EMPTY_STMT (TREE_OPERAND (*ptr, 1)))
11608             {
11609               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11610               tree *next = &TREE_OPERAND (*ptr, 1);
11611               TREE_OPERAND (*ptr, 0) = cur;
11612               if (IS_EMPTY_STMT (cur))
11613                 {
11614                   /* Optimization;  makes it easier to detect empty bodies.
11615                      Most useful for <clinit> with all-constant initializer. */
11616                   *ptr = *next;
11617                   continue;
11618                 }
11619               if (TREE_CODE (cur) == ERROR_MARK)
11620                 error_seen++;
11621               else if (! CAN_COMPLETE_NORMALLY (cur))
11622                 {
11623                   wfl_op2 = *next;
11624                   for (;;)
11625                     {
11626                       if (TREE_CODE (wfl_op2) == BLOCK)
11627                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11628                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11629                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11630                       else
11631                         break;
11632                     }
11633                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11634                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11635                     unreachable_stmt_error (*ptr);
11636                 }
11637               if (TREE_TYPE (*ptr) == NULL_TREE)
11638                 TREE_TYPE (*ptr) = void_type_node;
11639               ptr = next;
11640             }
11641           *ptr = java_complete_tree (*ptr);
11642
11643           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11644             return error_mark_node;
11645           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11646         }
11647       /* Turn local bindings to null */
11648       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11649         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11650
11651       TREE_TYPE (node) = void_type_node;
11652       break;
11653
11654       /* 2- They are expressions but ultimately deal with statements */
11655
11656     case THROW_EXPR:
11657       wfl_op1 = TREE_OPERAND (node, 0);
11658       COMPLETE_CHECK_OP_0 (node);
11659       /* 14.19 A throw statement cannot complete normally. */
11660       CAN_COMPLETE_NORMALLY (node) = 0;
11661       return patch_throw_statement (node, wfl_op1);
11662
11663     case SYNCHRONIZED_EXPR:
11664       wfl_op1 = TREE_OPERAND (node, 0);
11665       return patch_synchronized_statement (node, wfl_op1);
11666
11667     case TRY_EXPR:
11668       return patch_try_statement (node);
11669
11670     case TRY_FINALLY_EXPR:
11671       COMPLETE_CHECK_OP_0 (node);
11672       COMPLETE_CHECK_OP_1 (node);
11673       if (IS_EMPTY_STMT (TREE_OPERAND (node, 0)))
11674         /* Reduce try/finally nodes with an empty try block.  */
11675         return TREE_OPERAND (node, 1);
11676       if (IS_EMPTY_STMT (TREE_OPERAND (node, 1)))
11677         /* Likewise for an empty finally block.  */
11678         return TREE_OPERAND (node, 0);
11679       CAN_COMPLETE_NORMALLY (node)
11680         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11681            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11682       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11683       return node;
11684
11685     case LABELED_BLOCK_EXPR:
11686       PUSH_LABELED_BLOCK (node);
11687       if (LABELED_BLOCK_BODY (node))
11688         COMPLETE_CHECK_OP_1 (node);
11689       TREE_TYPE (node) = void_type_node;
11690       POP_LABELED_BLOCK ();
11691
11692       if (IS_EMPTY_STMT (LABELED_BLOCK_BODY (node)))
11693         {
11694           LABELED_BLOCK_BODY (node) = NULL_TREE;
11695           CAN_COMPLETE_NORMALLY (node) = 1;
11696         }
11697       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11698         CAN_COMPLETE_NORMALLY (node) = 1;
11699       return node;
11700
11701     case EXIT_BLOCK_EXPR:
11702       return patch_bc_statement (node);
11703
11704     case CASE_EXPR:
11705       cn = java_complete_tree (TREE_OPERAND (node, 0));
11706       if (cn == error_mark_node)
11707         return cn;
11708
11709       /* First, the case expression must be constant. Values of final
11710          fields are accepted. */
11711       cn = fold (cn);
11712       if ((TREE_CODE (cn) == COMPOUND_EXPR || TREE_CODE (cn) == COMPONENT_REF)
11713           && JDECL_P (TREE_OPERAND (cn, 1))
11714           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11715           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11716         {
11717           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11718                                        TREE_OPERAND (cn, 1));
11719         }
11720       /* Accept final locals too. */
11721       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn)
11722                && DECL_INITIAL (cn))
11723         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11724
11725       if (!TREE_CONSTANT (cn))
11726         {
11727           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11728           parse_error_context (node, "Constant expression required");
11729           return error_mark_node;
11730         }
11731
11732       nn = ctxp->current_loop;
11733
11734       /* It must be assignable to the type of the switch expression. */
11735       if (!try_builtin_assignconv (NULL_TREE,
11736                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11737         {
11738           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11739           parse_error_context
11740             (wfl_operator,
11741              "Incompatible type for case. Can't convert %qs to %<int%>",
11742              lang_printable_name (TREE_TYPE (cn), 0));
11743           return error_mark_node;
11744         }
11745
11746       cn = fold (convert (int_type_node, cn));
11747       TREE_CONSTANT_OVERFLOW (cn) = 0;
11748       CAN_COMPLETE_NORMALLY (cn) = 1;
11749
11750       /* Save the label on a list so that we can later check for
11751          duplicates.  */
11752       case_label_list = tree_cons (node, cn, case_label_list);
11753
11754       /* Multiple instance of a case label bearing the same value is
11755          checked later. The case expression is all right so far. */
11756       if (TREE_CODE (cn) == VAR_DECL)
11757         cn = DECL_INITIAL (cn);
11758       TREE_OPERAND (node, 0) = cn;
11759       TREE_TYPE (node) = void_type_node;
11760       CAN_COMPLETE_NORMALLY (node) = 1;
11761       TREE_SIDE_EFFECTS (node) = 1;
11762       break;
11763
11764     case DEFAULT_EXPR:
11765       nn = ctxp->current_loop;
11766       /* Only one default label is allowed per switch statement */
11767       if (SWITCH_HAS_DEFAULT (nn))
11768         {
11769 #ifdef USE_MAPPED_LOCATION
11770           SET_EXPR_LOCATION (wfl_operator, EXPR_LOCATION (node));
11771 #else
11772           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11773 #endif
11774           parse_error_context (wfl_operator,
11775                                "Duplicate case label: %<default%>");
11776           return error_mark_node;
11777         }
11778       else
11779         SWITCH_HAS_DEFAULT (nn) = 1;
11780       TREE_TYPE (node) = void_type_node;
11781       TREE_SIDE_EFFECTS (node) = 1;
11782       CAN_COMPLETE_NORMALLY (node) = 1;
11783       break;
11784
11785     case SWITCH_EXPR:
11786     case LOOP_EXPR:
11787       PUSH_LOOP (node);
11788       /* Check whether the loop was enclosed in a labeled
11789          statement. If not, create one, insert the loop in it and
11790          return the node */
11791       nn = patch_loop_statement (node);
11792
11793       /* Anyways, walk the body of the loop */
11794       if (TREE_CODE (node) == LOOP_EXPR)
11795         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11796       /* Switch statement: walk the switch expression and the cases */
11797       else
11798         node = patch_switch_statement (node);
11799
11800       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11801         nn = error_mark_node;
11802       else
11803         {
11804           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11805           /* If we returned something different, that's because we
11806              inserted a label. Pop the label too. */
11807           if (nn != node)
11808             {
11809               if (CAN_COMPLETE_NORMALLY (node))
11810                 CAN_COMPLETE_NORMALLY (nn) = 1;
11811               POP_LABELED_BLOCK ();
11812             }
11813         }
11814       POP_LOOP ();
11815       return nn;
11816
11817     case EXIT_EXPR:
11818       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11819       return patch_exit_expr (node);
11820
11821     case COND_EXPR:
11822       /* Condition */
11823       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11824       if (TREE_OPERAND (node, 0) == error_mark_node)
11825         return error_mark_node;
11826       /* then-else branches */
11827       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11828       if (TREE_OPERAND (node, 1) == error_mark_node)
11829         return error_mark_node;
11830       {
11831         /* This is a special case due to build_assertion().  When
11832            assertions are disabled we build a COND_EXPR in which
11833            Operand 1 is the body of the assertion.  If that happens to
11834            be a string concatenation we'll need to patch it here.  */
11835         tree patched = patch_string (TREE_OPERAND (node, 1));
11836         if (patched)
11837           TREE_OPERAND (node, 1) = patched;
11838       }
11839      TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
11840       if (TREE_OPERAND (node, 2) == error_mark_node)
11841         return error_mark_node;
11842       return patch_if_else_statement (node);
11843       break;
11844
11845     case CONDITIONAL_EXPR:
11846       /* Condition */
11847       wfl_op1 = TREE_OPERAND (node, 0);
11848       COMPLETE_CHECK_OP_0 (node);
11849       wfl_op2 = TREE_OPERAND (node, 1);
11850       COMPLETE_CHECK_OP_1 (node);
11851       wfl_op3 = TREE_OPERAND (node, 2);
11852       COMPLETE_CHECK_OP_2 (node);
11853       return patch_conditional_expr (node, wfl_op1, wfl_op2);
11854
11855       /* 3- Expression section */
11856     case COMPOUND_EXPR:
11857       wfl_op2 = TREE_OPERAND (node, 1);
11858       TREE_OPERAND (node, 0) = nn =
11859         java_complete_tree (TREE_OPERAND (node, 0));
11860       if (IS_EMPTY_STMT (wfl_op2))
11861         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
11862       else
11863         {
11864           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
11865             {
11866               /* An unreachable condition in a do-while statement
11867                  is *not* (technically) an unreachable statement. */
11868               nn = wfl_op2;
11869               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
11870                 nn = EXPR_WFL_NODE (nn);
11871               /* NN can be NULL_TREE exactly when UPDATE is, in
11872                  finish_for_loop.  */
11873               if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
11874                 {
11875                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
11876                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
11877                     {
11878                       /* Perhaps this warning should have an
11879                          associated flag.  The code being compiled is
11880                          pedantically correct, but useless.  */
11881                       parse_warning_context (wfl_operator,
11882                                              "Unreachable statement");
11883                     }
11884                   else
11885                     parse_error_context (wfl_operator,
11886                                          "Unreachable statement");
11887                 }
11888             }
11889           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11890           if (TREE_OPERAND (node, 1) == error_mark_node)
11891             return error_mark_node;
11892           /* Even though we might allow the case where the first
11893              operand doesn't return normally, we still should compute
11894              CAN_COMPLETE_NORMALLY correctly.  */
11895           CAN_COMPLETE_NORMALLY (node)
11896             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11897                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11898         }
11899       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
11900       break;
11901
11902     case RETURN_EXPR:
11903       /* CAN_COMPLETE_NORMALLY (node) = 0; */
11904       return patch_return (node);
11905
11906     case EXPR_WITH_FILE_LOCATION:
11907       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
11908           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
11909         {
11910           node = resolve_expression_name (node, NULL);
11911           if (node == error_mark_node)
11912             return node;
11913           CAN_COMPLETE_NORMALLY (node) = 1;
11914         }
11915       else
11916         {
11917           tree body;
11918           location_t save_location = input_location;
11919 #ifdef USE_MAPPED_LOCATION
11920           input_location = EXPR_LOCATION (node);
11921           if (input_location == UNKNOWN_LOCATION)
11922             input_location = save_location;
11923 #else
11924           input_line = EXPR_WFL_LINENO (node);
11925 #endif
11926           body = java_complete_tree (EXPR_WFL_NODE (node));
11927           input_location = save_location;
11928           EXPR_WFL_NODE (node) = body;
11929           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
11930           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
11931           if (IS_EMPTY_STMT (body) || TREE_CONSTANT (body))
11932             {
11933               /* Makes it easier to constant fold, detect empty bodies. */
11934               return body;
11935             }
11936           if (body == error_mark_node)
11937             {
11938               /* Its important for the evaluation of assignment that
11939                  this mark on the TREE_TYPE is propagated. */
11940               TREE_TYPE (node) = error_mark_node;
11941               return error_mark_node;
11942             }
11943           else
11944             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
11945
11946         }
11947       break;
11948
11949     case NEW_ARRAY_EXPR:
11950       /* Patch all the dimensions */
11951       flag = 0;
11952       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
11953         {
11954           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
11955           tree dim = convert (int_type_node,
11956                               java_complete_tree (TREE_VALUE (cn)));
11957           if (dim == error_mark_node)
11958             {
11959               flag = 1;
11960               continue;
11961             }
11962           else
11963             {
11964               TREE_VALUE (cn) = dim;
11965               /* Setup the location of the current dimension, for
11966                  later error report. */
11967 #ifdef USE_MAPPED_LOCATION
11968               TREE_PURPOSE (cn) = expr_add_location (NULL_TREE, location, 0);
11969 #else
11970               TREE_PURPOSE (cn) =
11971                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
11972               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
11973 #endif
11974             }
11975         }
11976       /* They complete the array creation expression, if no errors
11977          were found. */
11978       CAN_COMPLETE_NORMALLY (node) = 1;
11979       return (flag ? error_mark_node
11980               : force_evaluation_order (patch_newarray (node)));
11981
11982     case NEW_ANONYMOUS_ARRAY_EXPR:
11983       /* Create the array type if necessary. */
11984       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
11985         {
11986           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
11987           if (!(type = resolve_type_during_patch (type)))
11988             return error_mark_node;
11989           type = build_array_from_name (type, NULL_TREE,
11990                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
11991           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
11992         }
11993       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
11994                                    ANONYMOUS_ARRAY_INITIALIZER (node));
11995       if (node == error_mark_node)
11996         return error_mark_node;
11997       CAN_COMPLETE_NORMALLY (node) = 1;
11998       return node;
11999
12000     case NEW_CLASS_EXPR:
12001     case CALL_EXPR:
12002       /* Complete function's argument(s) first */
12003       if (complete_function_arguments (node))
12004         return error_mark_node;
12005       else
12006         {
12007           tree decl, wfl = TREE_OPERAND (node, 0);
12008           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
12009           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
12010                            super_identifier_node);
12011           tree arguments;
12012 #ifdef USE_MAPPED_LOCATION
12013           source_location location = EXPR_LOCATION (node);
12014 #else
12015           int location = EXPR_WFL_LINECOL (node);
12016 #endif
12017
12018           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
12019                                           from_super, 0, &decl);
12020           if (node == error_mark_node)
12021             return error_mark_node;
12022
12023           if (TREE_CODE (node) == CALL_EXPR
12024               && TREE_OPERAND (node, 1) != NULL_TREE)
12025             arguments = TREE_VALUE (TREE_OPERAND (node, 1));
12026           else
12027             arguments = NULL_TREE;
12028           check_thrown_exceptions (location, decl, arguments);
12029           /* If we call this(...), register signature and positions */
12030           if (in_this)
12031             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
12032               tree_cons (wfl, decl,
12033                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
12034           CAN_COMPLETE_NORMALLY (node) = 1;
12035           return force_evaluation_order (node);
12036         }
12037
12038     case MODIFY_EXPR:
12039       /* Save potential wfls */
12040       wfl_op1 = TREE_OPERAND (node, 0);
12041       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
12042
12043       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
12044           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
12045           && DECL_INITIAL (nn) != NULL_TREE)
12046         {
12047           tree value;
12048
12049           value = fold_constant_for_init (nn, nn);
12050
12051           /* When we have a primitype type, or a string and we're not
12052              emitting a class file, we actually don't want to generate
12053              anything for the assignment. */
12054           if (value != NULL_TREE &&
12055               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
12056                (TREE_TYPE (value) == string_ptr_type_node &&
12057                 ! flag_emit_class_files)))
12058             {
12059               /* Prepare node for patch_assignment */
12060               TREE_OPERAND (node, 1) = value;
12061               /* Call patch assignment to verify the assignment */
12062               if (patch_assignment (node, wfl_op1) == error_mark_node)
12063                 return error_mark_node;
12064               /* Set DECL_INITIAL properly (a conversion might have
12065                  been decided by patch_assignment) and return the
12066                  empty statement. */
12067               else
12068                 {
12069                   tree patched = patch_string (TREE_OPERAND (node, 1));
12070                   if (patched)
12071                     DECL_INITIAL (nn) = patched;
12072                   else
12073                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12074                   DECL_FIELD_FINAL_IUD (nn) = 1;
12075                   return build_java_empty_stmt ();
12076                 }
12077             }
12078           if (! flag_emit_class_files)
12079             DECL_INITIAL (nn) = NULL_TREE;
12080         }
12081       wfl_op2 = TREE_OPERAND (node, 1);
12082
12083       if (TREE_OPERAND (node, 0) == error_mark_node)
12084         return error_mark_node;
12085
12086       flag = COMPOUND_ASSIGN_P (wfl_op2);
12087       if (flag)
12088         {
12089           /* This might break when accessing outer field from inner
12090              class. TESTME, FIXME */
12091           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
12092
12093           /* Hand stabilize the lhs on both places */
12094           TREE_OPERAND (node, 0) = lvalue;
12095           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
12096             (flag_emit_class_files ? lvalue : save_expr (lvalue));
12097
12098           /* 15.25.2.a: Left hand is not an array access. FIXME */
12099           /* Now complete the RHS. We write it back later on. */
12100           nn = java_complete_tree (TREE_OPERAND (node, 1));
12101
12102           if ((cn = patch_string (nn)))
12103             nn = cn;
12104
12105           /* The last part of the rewrite for E1 op= E2 is to have
12106              E1 = (T)(E1 op E2), with T being the type of E1. */
12107           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
12108                                                TREE_TYPE (lvalue), nn));
12109
12110           /* If the assignment is compound and has reference type,
12111              then ensure the LHS has type String and nothing else.  */
12112           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
12113               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
12114             parse_error_context (wfl_op2,
12115                                  "Incompatible type for %<+=%>. Can't convert %qs to %<java.lang.String%>",
12116                                  lang_printable_name (TREE_TYPE (lvalue), 0));
12117
12118           /* 15.25.2.b: Left hand is an array access. FIXME */
12119         }
12120
12121       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12122          function to complete this RHS. Note that a NEW_ARRAY_INIT
12123          might have been already fully expanded if created as a result
12124          of processing an anonymous array initializer. We avoid doing
12125          the operation twice by testing whether the node already bears
12126          a type. */
12127       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12128         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12129                                    TREE_OPERAND (node, 1));
12130       /* Otherwise we simply complete the RHS */
12131       else
12132         nn = java_complete_tree (TREE_OPERAND (node, 1));
12133
12134       if (nn == error_mark_node)
12135         return error_mark_node;
12136
12137       /* Write back the RHS as we evaluated it. */
12138       TREE_OPERAND (node, 1) = nn;
12139
12140       /* In case we're handling = with a String as a RHS, we need to
12141          produce a String out of the RHS (it might still be a
12142          STRING_CST or a StringBuffer at this stage */
12143       if ((nn = patch_string (TREE_OPERAND (node, 1))))
12144         TREE_OPERAND (node, 1) = nn;
12145
12146       if ((nn = outer_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12147                                         TREE_OPERAND (node, 1))))
12148         {
12149           /* We return error_mark_node if outer_field_access_fix
12150              detects we write into a final. */
12151           if (nn == error_mark_node)
12152             return error_mark_node;
12153           node = nn;
12154         }
12155       else
12156         {
12157           node = patch_assignment (node, wfl_op1);
12158           if (node == error_mark_node)
12159             return error_mark_node;
12160           /* Reorganize the tree if necessary. */
12161           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12162                        || JSTRING_P (TREE_TYPE (node))))
12163             node = java_refold (node);
12164         }
12165
12166       /* Seek to set DECL_INITIAL to a proper value, since it might have
12167          undergone a conversion in patch_assignment. We do that only when
12168          it's necessary to have DECL_INITIAL properly set. */
12169       nn = TREE_OPERAND (node, 0);
12170       if (TREE_CODE (nn) == VAR_DECL
12171           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12172           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12173           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12174               || TREE_TYPE (nn) == string_ptr_type_node))
12175         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12176
12177       CAN_COMPLETE_NORMALLY (node) = 1;
12178       return node;
12179
12180     case MULT_EXPR:
12181     case PLUS_EXPR:
12182     case MINUS_EXPR:
12183     case LSHIFT_EXPR:
12184     case RSHIFT_EXPR:
12185     case URSHIFT_EXPR:
12186     case BIT_AND_EXPR:
12187     case BIT_XOR_EXPR:
12188     case BIT_IOR_EXPR:
12189     case TRUNC_MOD_EXPR:
12190     case TRUNC_DIV_EXPR:
12191     case RDIV_EXPR:
12192     case TRUTH_ANDIF_EXPR:
12193     case TRUTH_ORIF_EXPR:
12194     case EQ_EXPR:
12195     case NE_EXPR:
12196     case GT_EXPR:
12197     case GE_EXPR:
12198     case LT_EXPR:
12199     case LE_EXPR:
12200       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12201          knows how to handle those cases. */
12202       wfl_op1 = TREE_OPERAND (node, 0);
12203       wfl_op2 = TREE_OPERAND (node, 1);
12204
12205       CAN_COMPLETE_NORMALLY (node) = 1;
12206       /* Don't complete string nodes if dealing with the PLUS operand. */
12207       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12208         {
12209           nn = java_complete_tree (wfl_op1);
12210           if (nn == error_mark_node)
12211             return error_mark_node;
12212
12213           TREE_OPERAND (node, 0) = nn;
12214         }
12215       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12216         {
12217           nn = java_complete_tree (wfl_op2);
12218           if (nn == error_mark_node)
12219             return error_mark_node;
12220
12221           TREE_OPERAND (node, 1) = nn;
12222         }
12223       return patch_binop (node, wfl_op1, wfl_op2);
12224
12225     case INSTANCEOF_EXPR:
12226       wfl_op1 = TREE_OPERAND (node, 0);
12227       COMPLETE_CHECK_OP_0 (node);
12228       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1));
12229
12230     case UNARY_PLUS_EXPR:
12231     case NEGATE_EXPR:
12232     case TRUTH_NOT_EXPR:
12233     case BIT_NOT_EXPR:
12234     case PREDECREMENT_EXPR:
12235     case PREINCREMENT_EXPR:
12236     case POSTDECREMENT_EXPR:
12237     case POSTINCREMENT_EXPR:
12238     case CONVERT_EXPR:
12239       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12240          how to handle those cases. */
12241       wfl_op1 = TREE_OPERAND (node, 0);
12242       CAN_COMPLETE_NORMALLY (node) = 1;
12243       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12244       if (TREE_OPERAND (node, 0) == error_mark_node)
12245         return error_mark_node;
12246       node = patch_unaryop (node, wfl_op1);
12247       CAN_COMPLETE_NORMALLY (node) = 1;
12248       break;
12249
12250     case ARRAY_REF:
12251       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12252          how to handle those cases. */
12253       wfl_op1 = TREE_OPERAND (node, 0);
12254       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12255       if (TREE_OPERAND (node, 0) == error_mark_node)
12256         return error_mark_node;
12257       if (!flag_emit_class_files)
12258         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12259       /* The same applies to wfl_op2 */
12260       wfl_op2 = TREE_OPERAND (node, 1);
12261       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12262       if (TREE_OPERAND (node, 1) == error_mark_node)
12263         return error_mark_node;
12264       if (!flag_emit_class_files)
12265         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12266       return patch_array_ref (node);
12267
12268     case RECORD_TYPE:
12269       return node;;
12270
12271     case COMPONENT_REF:
12272       /* The first step in the re-write of qualified name handling.  FIXME.
12273          So far, this is only to support PRIMTYPE.class -> PRIMCLASS.TYPE. */
12274       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
12275       if (TREE_CODE (TREE_OPERAND (node, 0)) == RECORD_TYPE)
12276         {
12277           tree name = TREE_OPERAND (node, 1);
12278           tree field = lookup_field_wrapper (TREE_OPERAND (node, 0), name);
12279           if (field == NULL_TREE)
12280             {
12281               error ("missing static field %qs", IDENTIFIER_POINTER (name));
12282               return error_mark_node;
12283             }
12284           if (! FIELD_STATIC (field))
12285             {
12286               error ("not a static field %qs", IDENTIFIER_POINTER (name));
12287               return error_mark_node;
12288             }
12289           return field;
12290         }
12291       else
12292         abort ();
12293       break;
12294
12295     case THIS_EXPR:
12296       /* Can't use THIS in a static environment */
12297       if (!current_this)
12298         {
12299           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12300           parse_error_context (wfl_operator,
12301                                "Keyword %<this%> used outside allowed context");
12302           TREE_TYPE (node) = error_mark_node;
12303           return error_mark_node;
12304         }
12305       if (ctxp->explicit_constructor_p)
12306         {
12307           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12308           parse_error_context
12309             (wfl_operator, "Can't reference %<this%> or %<super%> before the superclass constructor has been called");
12310           TREE_TYPE (node) = error_mark_node;
12311           return error_mark_node;
12312         }
12313       return current_this;
12314
12315     case CLASS_LITERAL:
12316       CAN_COMPLETE_NORMALLY (node) = 1;
12317       node = patch_incomplete_class_ref (node);
12318       if (node == error_mark_node)
12319         return error_mark_node;
12320       break;
12321
12322     default:
12323       CAN_COMPLETE_NORMALLY (node) = 1;
12324       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12325          and it's time to turn it into the appropriate String object */
12326       if ((nn = patch_string (node)))
12327         node = nn;
12328       else
12329         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12330     }
12331   return node;
12332 }
12333
12334 /* Complete function call's argument. Return a nonzero value is an
12335    error was found.  */
12336
12337 static int
12338 complete_function_arguments (tree node)
12339 {
12340   int flag = 0;
12341   tree cn;
12342
12343   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12344   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12345     {
12346       tree wfl = TREE_VALUE (cn), parm, temp;
12347       parm = java_complete_tree (wfl);
12348
12349       if (parm == error_mark_node)
12350         {
12351           flag = 1;
12352           continue;
12353         }
12354       /* If we have a string literal that we haven't transformed yet or a
12355          crafted string buffer, as a result of the use of the String
12356          `+' operator. Build `parm.toString()' and expand it. */
12357       if ((temp = patch_string (parm)))
12358         parm = temp;
12359
12360       TREE_VALUE (cn) = parm;
12361     }
12362   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12363   return flag;
12364 }
12365
12366 /* Sometimes (for loops and variable initialized during their
12367    declaration), we want to wrap a statement around a WFL and turn it
12368    debugable.  */
12369
12370 static tree
12371 build_debugable_stmt (int location, tree stmt)
12372 {
12373   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12374     {
12375 #ifdef USE_MAPPED_LOCATION
12376       stmt = expr_add_location (stmt, location, 1);
12377 #else
12378       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12379       EXPR_WFL_LINECOL (stmt) = location;
12380       JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12381 #endif
12382     }
12383   return stmt;
12384 }
12385
12386 static tree
12387 build_expr_block (tree body, tree decls)
12388 {
12389   tree node = make_node (BLOCK);
12390   BLOCK_EXPR_DECLS (node) = decls;
12391   BLOCK_EXPR_BODY (node) = body;
12392   if (body)
12393     TREE_TYPE (node) = TREE_TYPE (body);
12394   TREE_SIDE_EFFECTS (node) = 1;
12395   return node;
12396 }
12397
12398 /* Create a new function block and link it appropriately to current
12399    function block chain */
12400
12401 static tree
12402 enter_block (void)
12403 {
12404   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12405
12406   /* Link block B supercontext to the previous block. The current
12407      function DECL is used as supercontext when enter_a_block is called
12408      for the first time for a given function. The current function body
12409      (DECL_FUNCTION_BODY) is set to be block B.  */
12410
12411   tree fndecl = current_function_decl;
12412
12413   if (!fndecl) {
12414     BLOCK_SUPERCONTEXT (b) = current_static_block;
12415     current_static_block = b;
12416   }
12417
12418   else if (!DECL_FUNCTION_BODY (fndecl))
12419     {
12420       BLOCK_SUPERCONTEXT (b) = fndecl;
12421       DECL_FUNCTION_BODY (fndecl) = b;
12422     }
12423   else
12424     {
12425       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12426       DECL_FUNCTION_BODY (fndecl) = b;
12427     }
12428   return b;
12429 }
12430
12431 /* Exit a block by changing the current function body
12432    (DECL_FUNCTION_BODY) to the current block super context, only if
12433    the block being exited isn't the method's top level one.  */
12434
12435 static tree
12436 exit_block (void)
12437 {
12438   tree b;
12439   if (current_function_decl)
12440     {
12441       b = DECL_FUNCTION_BODY (current_function_decl);
12442       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12443         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12444     }
12445   else
12446     {
12447       b = current_static_block;
12448
12449       if (BLOCK_SUPERCONTEXT (b))
12450         current_static_block = BLOCK_SUPERCONTEXT (b);
12451     }
12452   return b;
12453 }
12454
12455 /* Lookup for NAME in the nested function's blocks, all the way up to
12456    the current toplevel one. It complies with Java's local variable
12457    scoping rules.  */
12458
12459 static tree
12460 lookup_name_in_blocks (tree name)
12461 {
12462   tree b = GET_CURRENT_BLOCK (current_function_decl);
12463
12464   while (b != current_function_decl)
12465     {
12466       tree current;
12467
12468       /* Paranoid sanity check. To be removed */
12469       if (TREE_CODE (b) != BLOCK)
12470         abort ();
12471
12472       for (current = BLOCK_EXPR_DECLS (b); current;
12473            current = TREE_CHAIN (current))
12474         if (DECL_NAME (current) == name)
12475           return current;
12476       b = BLOCK_SUPERCONTEXT (b);
12477     }
12478   return NULL_TREE;
12479 }
12480
12481 static void
12482 maybe_absorb_scoping_blocks (void)
12483 {
12484   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12485     {
12486       tree b = exit_block ();
12487       java_method_add_stmt (current_function_decl, b);
12488       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12489     }
12490 }
12491
12492 \f
12493 /* This section of the source is reserved to build_* functions that
12494    are building incomplete tree nodes and the patch_* functions that
12495    are completing them.  */
12496
12497 /* Wrap a non WFL node around a WFL.  */
12498
12499 static tree
12500 build_wfl_wrap (tree node, int location)
12501 {
12502   tree wfl, node_to_insert = node;
12503
12504   /* We want to process THIS . xxx symbolically, to keep it consistent
12505      with the way we're processing SUPER. A THIS from a primary as a
12506      different form than a SUPER. Turn THIS into something symbolic */
12507   if (TREE_CODE (node) == THIS_EXPR)
12508     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12509   else
12510 #ifdef USE_MAPPED_LOCATION
12511     wfl = build_unknown_wfl (NULL_TREE);
12512
12513   SET_EXPR_LOCATION (wfl, location);
12514 #else
12515     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12516
12517   EXPR_WFL_LINECOL (wfl) = location;
12518 #endif
12519   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12520   return wfl;
12521 }
12522
12523 /* Build a super() constructor invocation. Returns an empty statement if
12524    we're currently dealing with the class java.lang.Object. */
12525
12526 static tree
12527 build_super_invocation (tree mdecl)
12528 {
12529   if (DECL_CONTEXT (mdecl) == object_type_node)
12530     return build_java_empty_stmt ();
12531   else
12532     {
12533       tree super_wfl = build_wfl_node (super_identifier_node);
12534       tree a = NULL_TREE, t;
12535
12536       /* This is called after parsing is done, so the parser context
12537          won't be accurate. Set location info from current_class decl. */
12538       tree class_wfl = lookup_cl (TYPE_NAME (current_class));
12539       EXPR_WFL_LINECOL (super_wfl) = EXPR_WFL_LINECOL (class_wfl);
12540
12541       /* If we're dealing with an anonymous class, pass the arguments
12542          of the crafted constructor along. */
12543       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12544         {
12545           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12546           for (; t != end_params_node; t = TREE_CHAIN (t))
12547             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12548         }
12549       return build_method_invocation (super_wfl, a);
12550     }
12551 }
12552
12553 /* Build a SUPER/THIS qualified method invocation.  */
12554
12555 static tree
12556 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12557                                        int lloc, int rloc)
12558 {
12559   tree invok;
12560   tree wfl =
12561     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12562   EXPR_WFL_LINECOL (wfl) = lloc;
12563   invok = build_method_invocation (name, args);
12564   return make_qualified_primary (wfl, invok, rloc);
12565 }
12566
12567 /* Build an incomplete CALL_EXPR node. */
12568
12569 static tree
12570 build_method_invocation (tree name, tree args)
12571 {
12572   tree call = build3 (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12573   TREE_SIDE_EFFECTS (call) = 1;
12574   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12575   return call;
12576 }
12577
12578 /* Build an incomplete new xxx(...) node. */
12579
12580 static tree
12581 build_new_invocation (tree name, tree args)
12582 {
12583   tree call = build3 (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12584   TREE_SIDE_EFFECTS (call) = 1;
12585   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12586   return call;
12587 }
12588
12589 /* Build an incomplete assignment expression. */
12590
12591 static tree
12592 build_assignment (int op, int op_location, tree lhs, tree rhs)
12593 {
12594   tree assignment;
12595   /* Build the corresponding binop if we deal with a Compound
12596      Assignment operator. Mark the binop sub-tree as part of a
12597      Compound Assignment expression */
12598   if (op != ASSIGN_TK)
12599     {
12600       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12601       COMPOUND_ASSIGN_P (rhs) = 1;
12602     }
12603   assignment = build2 (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12604   TREE_SIDE_EFFECTS (assignment) = 1;
12605   EXPR_WFL_LINECOL (assignment) = op_location;
12606   return assignment;
12607 }
12608
12609 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12610    the buffer.  This is used only for string conversion.  */
12611 static char *
12612 string_convert_int_cst (tree node)
12613 {
12614   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12615   static char buffer[21];
12616
12617   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12618   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12619   char *p = buffer + sizeof (buffer);
12620   int neg = 0;
12621
12622   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12623                                   << (HOST_BITS_PER_WIDE_INT - 1));
12624
12625   *--p = '\0';
12626
12627   /* If negative, note the fact and negate the value.  */
12628   if ((hi & hibit))
12629     {
12630       lo = ~lo;
12631       hi = ~hi;
12632       if (++lo == 0)
12633         ++hi;
12634       neg = 1;
12635     }
12636
12637   /* Divide by 10 until there are no bits left.  */
12638   do
12639     {
12640       unsigned HOST_WIDE_INT acc = 0;
12641       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12642       unsigned int i;
12643
12644       /* Use long division to compute the result and the remainder.  */
12645       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12646         {
12647           /* Shift a bit into accumulator.  */
12648           acc <<= 1;
12649           if ((hi & hibit))
12650             acc |= 1;
12651
12652           /* Shift the value.  */
12653           hi <<= 1;
12654           if ((lo & hibit))
12655             hi |= 1;
12656           lo <<= 1;
12657
12658           /* Shift the correct bit into the result.  */
12659           outhi <<= 1;
12660           if ((outlo & hibit))
12661             outhi |= 1;
12662           outlo <<= 1;
12663           if (acc >= 10)
12664             {
12665               acc -= 10;
12666               outlo |= 1;
12667             }
12668         }
12669
12670       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12671       *--p = '\060' + acc;
12672
12673       hi = outhi;
12674       lo = outlo;
12675     }
12676   while (hi || lo);
12677
12678   if (neg)
12679     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12680
12681   return p;
12682 }
12683
12684 /* Print an INTEGER_CST node in a static buffer, and return the
12685    buffer.  This is used only for error handling.  */
12686 char *
12687 print_int_node (tree node)
12688 {
12689   static char buffer [80];
12690   if (TREE_CONSTANT_OVERFLOW (node))
12691     sprintf (buffer, "<overflow>");
12692
12693   if (TREE_INT_CST_HIGH (node) == 0)
12694     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12695              TREE_INT_CST_LOW (node));
12696   else if (TREE_INT_CST_HIGH (node) == -1
12697            && TREE_INT_CST_LOW (node) != 0)
12698     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12699              -TREE_INT_CST_LOW (node));
12700   else
12701     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12702              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12703
12704   return buffer;
12705 }
12706
12707 \f
12708 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12709    context.  */
12710
12711 /* 15.25 Assignment operators. */
12712
12713 static tree
12714 patch_assignment (tree node, tree wfl_op1)
12715 {
12716   tree rhs = TREE_OPERAND (node, 1);
12717   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12718   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12719   int error_found = 0;
12720   int lvalue_from_array = 0;
12721   int is_return = 0;
12722
12723   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12724
12725   /* Lhs can be a named variable */
12726   if (JDECL_P (lvalue))
12727     {
12728       lhs_type = TREE_TYPE (lvalue);
12729     }
12730   /* Or Lhs can be an array access. */
12731   else if (TREE_CODE (lvalue) == ARRAY_REF)
12732     {
12733       lhs_type = TREE_TYPE (lvalue);
12734       lvalue_from_array = 1;
12735     }
12736   /* Or a field access */
12737   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12738     lhs_type = TREE_TYPE (lvalue);
12739   /* Or a function return slot */
12740   else if (TREE_CODE (lvalue) == RESULT_DECL)
12741     {
12742       /* If the return type is an integral type, then we create the
12743          RESULT_DECL with a promoted type, but we need to do these
12744          checks against the unpromoted type to ensure type safety.  So
12745          here we look at the real type, not the type of the decl we
12746          are modifying.  */
12747       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12748       is_return = 1;
12749     }
12750   /* Otherwise, we might want to try to write into an optimized static
12751      final, this is an of a different nature, reported further on. */
12752   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12753            && resolve_expression_name (wfl_op1, &llvalue))
12754     {
12755       lhs_type = TREE_TYPE (lvalue);
12756     }
12757   else
12758     {
12759       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12760       error_found = 1;
12761     }
12762
12763   rhs_type = TREE_TYPE (rhs);
12764
12765   /* 5.1 Try the assignment conversion for builtin type. */
12766   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12767
12768   /* 5.2 If it failed, try a reference conversion */
12769   if (!new_rhs)
12770     new_rhs = try_reference_assignconv (lhs_type, rhs);
12771
12772   /* 15.25.2 If we have a compound assignment, convert RHS into the
12773      type of the LHS */
12774   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12775     new_rhs = convert (lhs_type, rhs);
12776
12777   /* Explicit cast required. This is an error */
12778   if (!new_rhs)
12779     {
12780       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12781       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12782       tree wfl;
12783       char operation [32];      /* Max size known */
12784
12785       /* If the assignment is part of a declaration, we use the WFL of
12786          the declared variable to point out the error and call it a
12787          declaration problem. If the assignment is a genuine =
12788          operator, we call is a operator `=' problem, otherwise we
12789          call it an assignment problem. In both of these last cases,
12790          we use the WFL of the operator to indicate the error. */
12791
12792       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12793         {
12794           wfl = wfl_op1;
12795           strcpy (operation, "declaration");
12796         }
12797       else
12798         {
12799           wfl = wfl_operator;
12800           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12801             strcpy (operation, "assignment");
12802           else if (is_return)
12803             strcpy (operation, "'return'");
12804           else
12805             strcpy (operation, "'='");
12806         }
12807
12808       if (!valid_cast_to_p (rhs_type, lhs_type))
12809         parse_error_context
12810           (wfl, "Incompatible type for %s. Can't convert %qs to %qs",
12811            operation, t1, t2);
12812       else
12813         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert %qs to %qs",
12814                              operation, t1, t2);
12815       free (t1); free (t2);
12816       error_found = 1;
12817     }
12818
12819   if (error_found)
12820     return error_mark_node;
12821
12822   /* If we're processing a `return' statement, promote the actual type
12823      to the promoted type.  */
12824   if (is_return)
12825     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
12826
12827   /* 10.10: Array Store Exception runtime check */
12828   if (!flag_emit_class_files
12829       && lvalue_from_array
12830       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
12831     {
12832       tree array, store_check, base, index_expr;
12833
12834       /* Save RHS so that it doesn't get re-evaluated by the store check. */
12835       new_rhs = save_expr (new_rhs);
12836
12837       /* Get the INDIRECT_REF. */
12838       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
12839       /* Get the array pointer expr. */
12840       array = TREE_OPERAND (array, 0);
12841       store_check = build_java_arraystore_check (array, new_rhs);
12842
12843       index_expr = TREE_OPERAND (lvalue, 1);
12844
12845       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
12846         {
12847           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
12848              happen before the store check, so prepare to insert the store
12849              check within the second operand of the existing COMPOUND_EXPR. */
12850           base = index_expr;
12851         }
12852       else
12853         base = lvalue;
12854
12855       index_expr = TREE_OPERAND (base, 1);
12856       TREE_OPERAND (base, 1) = build2 (COMPOUND_EXPR, TREE_TYPE (index_expr),
12857                                        store_check, index_expr);
12858     }
12859
12860   /* Final locals can be used as case values in switch
12861      statement. Prepare them for this eventuality. */
12862   if (TREE_CODE (lvalue) == VAR_DECL
12863       && DECL_FINAL (lvalue)
12864       && TREE_CONSTANT (new_rhs)
12865       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
12866       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
12867       )
12868     {
12869       TREE_CONSTANT (lvalue) = 1;
12870       TREE_INVARIANT (lvalue) = 1;
12871       DECL_INITIAL (lvalue) = new_rhs;
12872     }
12873
12874   /* Copy the rhs if it's a reference.  */
12875   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
12876     {
12877       switch (TREE_CODE (new_rhs))
12878         {
12879         case ARRAY_REF:
12880         case INDIRECT_REF:
12881         case COMPONENT_REF:
12882           /* Transform a = foo.bar
12883              into a = ({int tmp; tmp = foo.bar;}).
12884              We need to ensure that if a read from memory fails
12885              because of a NullPointerException, a destination variable
12886              will remain unchanged.  An explicit temporary does what
12887              we need.
12888
12889              If flag_check_references is set, this is unnecessary
12890              because we'll check each reference before doing any
12891              reads.  If optimize is not set the result will never be
12892              written to a stack slot that contains the LHS.  */
12893           {
12894             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
12895                                    TREE_TYPE (new_rhs));
12896             tree block = make_node (BLOCK);
12897             tree assignment
12898               = build2 (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
12899             DECL_CONTEXT (tmp) = current_function_decl;
12900             TREE_TYPE (block) = TREE_TYPE (new_rhs);
12901             BLOCK_VARS (block) = tmp;
12902             BLOCK_EXPR_BODY (block) = assignment;
12903             TREE_SIDE_EFFECTS (block) = 1;
12904             new_rhs = block;
12905           }
12906           break;
12907         default:
12908           break;
12909         }
12910     }
12911
12912   TREE_OPERAND (node, 0) = lvalue;
12913   TREE_OPERAND (node, 1) = new_rhs;
12914   TREE_TYPE (node) = lhs_type;
12915   return node;
12916 }
12917
12918 /* Check that type SOURCE can be cast into type DEST. If the cast
12919    can't occur at all, return NULL; otherwise, return a possibly
12920    modified rhs.  */
12921
12922 static tree
12923 try_reference_assignconv (tree lhs_type, tree rhs)
12924 {
12925   tree new_rhs = NULL_TREE;
12926   tree rhs_type = TREE_TYPE (rhs);
12927
12928   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
12929     {
12930       /* `null' may be assigned to any reference type */
12931       if (rhs == null_pointer_node)
12932         new_rhs = null_pointer_node;
12933       /* Try the reference assignment conversion */
12934       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
12935         new_rhs = rhs;
12936       /* This is a magic assignment that we process differently */
12937       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
12938         new_rhs = rhs;
12939     }
12940   return new_rhs;
12941 }
12942
12943 /* Check that RHS can be converted into LHS_TYPE by the assignment
12944    conversion (5.2), for the cases of RHS being a builtin type. Return
12945    NULL_TREE if the conversion fails or if because RHS isn't of a
12946    builtin type. Return a converted RHS if the conversion is possible.  */
12947
12948 static tree
12949 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
12950 {
12951   tree new_rhs = NULL_TREE;
12952   tree rhs_type = TREE_TYPE (rhs);
12953
12954   /* Handle boolean specially.  */
12955   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12956       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12957     {
12958       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
12959           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
12960         new_rhs = rhs;
12961     }
12962
12963   /* 5.1.1 Try Identity Conversion,
12964      5.1.2 Try Widening Primitive Conversion */
12965   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
12966     new_rhs = convert (lhs_type, rhs);
12967
12968   /* Try a narrowing primitive conversion (5.1.3):
12969        - expression is a constant expression of type byte, short, char,
12970          or int, AND
12971        - variable is byte, short or char AND
12972        - The value of the expression is representable in the type of the
12973          variable */
12974   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
12975             || rhs_type == char_type_node || rhs_type == int_type_node)
12976             && TREE_CONSTANT (rhs)
12977            && (lhs_type == byte_type_node || lhs_type == char_type_node
12978                || lhs_type == short_type_node))
12979     {
12980       if (int_fits_type_p (rhs, lhs_type))
12981         new_rhs = convert (lhs_type, rhs);
12982       else if (wfl_op1)         /* Might be called with a NULL */
12983         parse_warning_context
12984           (wfl_op1,
12985            "Constant expression %qs too wide for narrowing primitive conversion to %qs",
12986            print_int_node (rhs), lang_printable_name (lhs_type, 0));
12987       /* Reported a warning that will turn into an error further
12988          down, so we don't return */
12989     }
12990
12991   return new_rhs;
12992 }
12993
12994 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
12995    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
12996    0 is the conversion test fails.  This implements parts the method
12997    invocation conversion (5.3).  */
12998
12999 static int
13000 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
13001 {
13002   /* 5.1.1: This is the identity conversion part. */
13003   if (lhs_type == rhs_type)
13004     return 1;
13005
13006   /* Reject non primitive types and boolean conversions.  */
13007   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
13008     return 0;
13009
13010   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
13011      than a char can't be converted into a char. Short can't too, but
13012      the < test below takes care of that */
13013   if (lhs_type == char_type_node && rhs_type == byte_type_node)
13014     return 0;
13015
13016   /* Accept all promoted type here. Note, we can't use <= in the test
13017      below, because we still need to bounce out assignments of short
13018      to char and the likes */
13019   if (lhs_type == int_type_node
13020       && (rhs_type == promoted_byte_type_node
13021           || rhs_type == promoted_short_type_node
13022           || rhs_type == promoted_char_type_node
13023           || rhs_type == promoted_boolean_type_node))
13024     return 1;
13025
13026   /* From here, an integral is widened if its precision is smaller
13027      than the precision of the LHS or if the LHS is a floating point
13028      type, or the RHS is a float and the RHS a double. */
13029   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
13030        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
13031       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
13032       || (rhs_type == float_type_node && lhs_type == double_type_node))
13033     return 1;
13034
13035   return 0;
13036 }
13037
13038 /* Check that something of SOURCE type can be assigned or cast to
13039    something of DEST type at runtime. Return 1 if the operation is
13040    valid, 0 otherwise. If CAST is set to 1, we're treating the case
13041    were SOURCE is cast into DEST, which borrows a lot of the
13042    assignment check. */
13043
13044 static int
13045 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
13046 {
13047   /* SOURCE or DEST might be null if not from a declared entity. */
13048   if (!source || !dest)
13049     return 0;
13050   if (JNULLP_TYPE_P (source))
13051     return 1;
13052   if (TREE_CODE (source) == POINTER_TYPE)
13053     source = TREE_TYPE (source);
13054   if (TREE_CODE (dest) == POINTER_TYPE)
13055     dest = TREE_TYPE (dest);
13056
13057   /* If source and dest are being compiled from bytecode, they may need to
13058      be loaded. */
13059   if (CLASS_P (source) && !CLASS_LOADED_P (source))
13060     {
13061       load_class (source, 1);
13062       safe_layout_class (source);
13063     }
13064   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
13065     {
13066       load_class (dest, 1);
13067       safe_layout_class (dest);
13068     }
13069
13070   /* Case where SOURCE is a class type */
13071   if (TYPE_CLASS_P (source))
13072     {
13073       if (TYPE_CLASS_P (dest))
13074         return  (source == dest
13075                  || inherits_from_p (source, dest)
13076                  || (cast && inherits_from_p (dest, source)));
13077       if (TYPE_INTERFACE_P (dest))
13078         {
13079           /* If doing a cast and SOURCE is final, the operation is
13080              always correct a compile time (because even if SOURCE
13081              does not implement DEST, a subclass of SOURCE might). */
13082           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
13083             return 1;
13084           /* Otherwise, SOURCE must implement DEST */
13085           return interface_of_p (dest, source);
13086         }
13087       /* DEST is an array, cast permitted if SOURCE is of Object type */
13088       return (cast && source == object_type_node ? 1 : 0);
13089     }
13090   if (TYPE_INTERFACE_P (source))
13091     {
13092       if (TYPE_CLASS_P (dest))
13093         {
13094           /* If not casting, DEST must be the Object type */
13095           if (!cast)
13096             return dest == object_type_node;
13097           /* We're doing a cast. The cast is always valid is class
13098              DEST is not final, otherwise, DEST must implement SOURCE */
13099           else if (!CLASS_FINAL (TYPE_NAME (dest)))
13100             return 1;
13101           else
13102             return interface_of_p (source, dest);
13103         }
13104       if (TYPE_INTERFACE_P (dest))
13105         {
13106           /* If doing a cast, then if SOURCE and DEST contain method
13107              with the same signature but different return type, then
13108              this is a (compile time) error */
13109           if (cast)
13110             {
13111               tree method_source, method_dest;
13112               tree source_type;
13113               tree source_sig;
13114               tree source_name;
13115               for (method_source = TYPE_METHODS (source); method_source;
13116                    method_source = TREE_CHAIN (method_source))
13117                 {
13118                   source_sig =
13119                     build_java_argument_signature (TREE_TYPE (method_source));
13120                   source_type = TREE_TYPE (TREE_TYPE (method_source));
13121                   source_name = DECL_NAME (method_source);
13122                   for (method_dest = TYPE_METHODS (dest);
13123                        method_dest; method_dest = TREE_CHAIN (method_dest))
13124                     if (source_sig ==
13125                         build_java_argument_signature (TREE_TYPE (method_dest))
13126                         && source_name == DECL_NAME (method_dest)
13127                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
13128                       return 0;
13129                 }
13130               return 1;
13131             }
13132           else
13133             return source == dest || interface_of_p (dest, source);
13134         }
13135       else
13136         {
13137           /* Array */
13138           return (cast
13139                   && (DECL_NAME (TYPE_NAME (source))
13140                       == java_lang_cloneable_identifier_node
13141                       || (DECL_NAME (TYPE_NAME (source))
13142                           == java_io_serializable_identifier_node)));
13143         }
13144     }
13145   if (TYPE_ARRAY_P (source))
13146     {
13147       if (TYPE_CLASS_P (dest))
13148         return dest == object_type_node;
13149       /* Can't cast an array to an interface unless the interface is
13150          java.lang.Cloneable or java.io.Serializable.  */
13151       if (TYPE_INTERFACE_P (dest))
13152         return (DECL_NAME (TYPE_NAME (dest))
13153                 == java_lang_cloneable_identifier_node
13154                 || (DECL_NAME (TYPE_NAME (dest))
13155                     == java_io_serializable_identifier_node));
13156       else                      /* Arrays */
13157         {
13158           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13159           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13160
13161           /* In case of severe errors, they turn out null */
13162           if (!dest_element_type || !source_element_type)
13163             return 0;
13164           if (source_element_type == dest_element_type)
13165             return 1;
13166           return valid_ref_assignconv_cast_p (source_element_type,
13167                                               dest_element_type, cast);
13168         }
13169       return 0;
13170     }
13171   return 0;
13172 }
13173
13174 static int
13175 valid_cast_to_p (tree source, tree dest)
13176 {
13177   if (TREE_CODE (source) == POINTER_TYPE)
13178     source = TREE_TYPE (source);
13179   if (TREE_CODE (dest) == POINTER_TYPE)
13180     dest = TREE_TYPE (dest);
13181
13182   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13183     return valid_ref_assignconv_cast_p (source, dest, 1);
13184
13185   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13186     return 1;
13187
13188   else if (TREE_CODE (source) == BOOLEAN_TYPE
13189            && TREE_CODE (dest) == BOOLEAN_TYPE)
13190     return 1;
13191
13192   return 0;
13193 }
13194
13195 static tree
13196 do_unary_numeric_promotion (tree arg)
13197 {
13198   tree type = TREE_TYPE (arg);
13199   if ((TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13200       || TREE_CODE (type) == CHAR_TYPE)
13201     arg = convert (int_type_node, arg);
13202   return arg;
13203 }
13204
13205 /* Return a nonzero value if SOURCE can be converted into DEST using
13206    the method invocation conversion rule (5.3).  */
13207 static int
13208 valid_method_invocation_conversion_p (tree dest, tree source)
13209 {
13210   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13211            && valid_builtin_assignconv_identity_widening_p (dest, source))
13212           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13213               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13214               && valid_ref_assignconv_cast_p (source, dest, 0)));
13215 }
13216
13217 /* Build an incomplete binop expression. */
13218
13219 static tree
13220 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13221 {
13222   tree binop = build2 (op, NULL_TREE, op1, op2);
13223   TREE_SIDE_EFFECTS (binop) = 1;
13224   /* Store the location of the operator, for better error report. The
13225      string of the operator will be rebuild based on the OP value. */
13226   EXPR_WFL_LINECOL (binop) = op_location;
13227   return binop;
13228 }
13229
13230 /* Build the string of the operator retained by NODE. If NODE is part
13231    of a compound expression, add an '=' at the end of the string. This
13232    function is called when an error needs to be reported on an
13233    operator. The string is returned as a pointer to a static character
13234    buffer. */
13235
13236 static char *
13237 operator_string (tree node)
13238 {
13239 #define BUILD_OPERATOR_STRING(S)                                        \
13240   {                                                                     \
13241     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13242     return buffer;                                                      \
13243   }
13244
13245   static char buffer [10];
13246   switch (TREE_CODE (node))
13247     {
13248     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13249     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13250     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13251     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13252     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13253     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13254     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13255     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13256     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13257     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13258     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13259     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13260     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13261     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13262     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13263     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13264     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13265     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13266     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13267     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13268     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13269     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13270     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13271     case PREINCREMENT_EXPR:     /* Fall through */
13272     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13273     case PREDECREMENT_EXPR:     /* Fall through */
13274     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13275     default:
13276       internal_error ("unregistered operator %s",
13277                       tree_code_name [TREE_CODE (node)]);
13278     }
13279   return NULL;
13280 #undef BUILD_OPERATOR_STRING
13281 }
13282
13283 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13284
13285 static int
13286 java_decl_equiv (tree var_acc1, tree var_acc2)
13287 {
13288   if (JDECL_P (var_acc1))
13289     return (var_acc1 == var_acc2);
13290
13291   return (TREE_CODE (var_acc1) == COMPONENT_REF
13292           && TREE_CODE (var_acc2) == COMPONENT_REF
13293           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13294              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13295           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13296 }
13297
13298 /* Return a nonzero value if CODE is one of the operators that can be
13299    used in conjunction with the `=' operator in a compound assignment.  */
13300
13301 static int
13302 binop_compound_p (enum tree_code code)
13303 {
13304   int i;
13305   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13306     if (binop_lookup [i] == code)
13307       break;
13308
13309   return i < BINOP_COMPOUND_CANDIDATES;
13310 }
13311
13312 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13313
13314 static tree
13315 java_refold (tree t)
13316 {
13317   tree c, b, ns, decl;
13318
13319   if (TREE_CODE (t) != MODIFY_EXPR)
13320     return t;
13321
13322   c = TREE_OPERAND (t, 1);
13323   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13324          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13325          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13326     return t;
13327
13328   /* Now the left branch of the binary operator. */
13329   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13330   if (! (b && TREE_CODE (b) == NOP_EXPR
13331          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13332     return t;
13333
13334   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13335   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13336          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13337     return t;
13338
13339   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13340   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13341       /* It's got to be the an equivalent decl */
13342       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13343     {
13344       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13345       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13346       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13347       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13348       /* Change the right part of the BINOP_EXPR */
13349       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13350     }
13351
13352   return t;
13353 }
13354
13355 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13356    errors but we modify NODE so that it contains the type computed
13357    according to the expression, when it's fixed. Otherwise, we write
13358    error_mark_node as the type. It allows us to further the analysis
13359    of remaining nodes and detects more errors in certain cases.  */
13360
13361 static tree
13362 patch_binop (tree node, tree wfl_op1, tree wfl_op2)
13363 {
13364   tree op1 = TREE_OPERAND (node, 0);
13365   tree op2 = TREE_OPERAND (node, 1);
13366   tree op1_type = TREE_TYPE (op1);
13367   tree op2_type = TREE_TYPE (op2);
13368   tree prom_type = NULL_TREE, cn;
13369   enum tree_code code = TREE_CODE (node);
13370
13371   /* If 1, tell the routine that we have to return error_mark_node
13372      after checking for the initialization of the RHS */
13373   int error_found = 0;
13374
13375   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13376
13377   /* If either op<n>_type are NULL, this might be early signs of an
13378      error situation, unless it's too early to tell (in case we're
13379      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13380      correctly so the error can be later on reported accurately. */
13381   if (! (code == PLUS_EXPR || code == NE_EXPR
13382          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13383     {
13384       tree n;
13385       if (! op1_type)
13386         {
13387           n = java_complete_tree (op1);
13388           op1_type = TREE_TYPE (n);
13389         }
13390       if (! op2_type)
13391         {
13392           n = java_complete_tree (op2);
13393           op2_type = TREE_TYPE (n);
13394         }
13395     }
13396
13397   switch (code)
13398     {
13399     /* 15.16 Multiplicative operators */
13400     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13401     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13402     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13403     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13404       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13405         {
13406           if (!JNUMERIC_TYPE_P (op1_type))
13407             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13408           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13409             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13410           TREE_TYPE (node) = error_mark_node;
13411           error_found = 1;
13412           break;
13413         }
13414       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13415
13416       /* Detect integral division by zero */
13417       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13418           && TREE_CODE (prom_type) == INTEGER_TYPE
13419           && (op2 == integer_zero_node || op2 == long_zero_node ||
13420               (TREE_CODE (op2) == INTEGER_CST &&
13421                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13422         {
13423           parse_warning_context
13424             (wfl_operator,
13425              "Evaluating this expression will result in an arithmetic exception being thrown");
13426           TREE_CONSTANT (node) = 0;
13427           TREE_INVARIANT (node) = 0;
13428         }
13429
13430       /* Change the division operator if necessary */
13431       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13432         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13433
13434       /* Before divisions as is disappear, try to simplify and bail if
13435          applicable, otherwise we won't perform even simple
13436          simplifications like (1-1)/3. We can't do that with floating
13437          point number, folds can't handle them at this stage. */
13438       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13439           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13440         {
13441           TREE_TYPE (node) = prom_type;
13442           node = fold (node);
13443           if (TREE_CODE (node) != code)
13444             return node;
13445         }
13446
13447       if (TREE_CODE (prom_type) == INTEGER_TYPE
13448           && flag_use_divide_subroutine
13449           && ! flag_emit_class_files
13450           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13451         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13452
13453       /* This one is more complicated. FLOATs are processed by a
13454          function call to soft_fmod. Duplicate the value of the
13455          COMPOUND_ASSIGN_P flag. */
13456       if (code == TRUNC_MOD_EXPR)
13457         {
13458           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13459           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13460           return mod;
13461         }
13462       break;
13463
13464     /* 15.17 Additive Operators */
13465     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13466
13467       /* Operation is valid if either one argument is a string
13468          constant, a String object or a StringBuffer crafted for the
13469          purpose of the a previous usage of the String concatenation
13470          operator */
13471
13472       if (TREE_CODE (op1) == STRING_CST
13473           || TREE_CODE (op2) == STRING_CST
13474           || JSTRING_TYPE_P (op1_type)
13475           || JSTRING_TYPE_P (op2_type)
13476           || IS_CRAFTED_STRING_BUFFER_P (op1)
13477           || IS_CRAFTED_STRING_BUFFER_P (op2))
13478         return build_string_concatenation (op1, op2);
13479
13480     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13481                                    Numeric Types */
13482       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13483         {
13484           if (!JNUMERIC_TYPE_P (op1_type))
13485             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13486           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13487             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13488           TREE_TYPE (node) = error_mark_node;
13489           error_found = 1;
13490           break;
13491         }
13492       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13493       break;
13494
13495     /* 15.18 Shift Operators */
13496     case LSHIFT_EXPR:
13497     case RSHIFT_EXPR:
13498     case URSHIFT_EXPR:
13499       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13500         {
13501           if (!JINTEGRAL_TYPE_P (op1_type))
13502             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13503           else
13504             {
13505               if (JNUMERIC_TYPE_P (op2_type))
13506                 parse_error_context (wfl_operator,
13507                                      "Incompatible type for %qs. Explicit cast needed to convert shift distance from %qs to integral",
13508                                      operator_string (node),
13509                                      lang_printable_name (op2_type, 0));
13510               else
13511                 parse_error_context (wfl_operator,
13512                                      "Incompatible type for %qs. Can't convert shift distance from %qs to integral",
13513                                      operator_string (node),
13514                                      lang_printable_name (op2_type, 0));
13515             }
13516           TREE_TYPE (node) = error_mark_node;
13517           error_found = 1;
13518           break;
13519         }
13520
13521       /* Unary numeric promotion (5.6.1) is performed on each operand
13522          separately */
13523       op1 = do_unary_numeric_promotion (op1);
13524       op2 = do_unary_numeric_promotion (op2);
13525
13526       /* If the right hand side is of type `long', first cast it to
13527          `int'.  */
13528       if (TREE_TYPE (op2) == long_type_node)
13529         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13530
13531       /* The type of the shift expression is the type of the promoted
13532          type of the left-hand operand */
13533       prom_type = TREE_TYPE (op1);
13534
13535       /* Shift int only up to 0x1f and long up to 0x3f */
13536       if (prom_type == int_type_node)
13537         op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
13538                             build_int_cst (NULL_TREE, 0x1f)));
13539       else
13540         op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
13541                             build_int_cst (NULL_TREE, 0x3f)));
13542
13543       /* The >>> operator is a >> operating on unsigned quantities */
13544       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
13545         {
13546           tree to_return;
13547           tree utype = java_unsigned_type (prom_type);
13548           op1 = convert (utype, op1);
13549           TREE_SET_CODE (node, RSHIFT_EXPR);
13550           TREE_OPERAND (node, 0) = op1;
13551           TREE_OPERAND (node, 1) = op2;
13552           TREE_TYPE (node) = utype;
13553           to_return = convert (prom_type, node);
13554           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13555           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13556           TREE_SIDE_EFFECTS (to_return)
13557             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13558           return to_return;
13559         }
13560       break;
13561
13562       /* 15.19.1 Type Comparison Operator instanceof */
13563     case INSTANCEOF_EXPR:
13564
13565       TREE_TYPE (node) = boolean_type_node;
13566
13567       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13568       if ((cn = patch_string (op1)))
13569         {
13570           op1 = cn;
13571           op1_type = TREE_TYPE (op1);
13572         }
13573       if (op1_type == NULL_TREE)
13574         abort ();
13575
13576       if (!(op2_type = resolve_type_during_patch (op2)))
13577         return error_mark_node;
13578
13579       /* The first operand must be a reference type or the null type */
13580       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13581         error_found = 1;        /* Error reported further below */
13582
13583       /* The second operand must be a reference type */
13584       if (!JREFERENCE_TYPE_P (op2_type))
13585         {
13586           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13587           parse_error_context
13588             (wfl_operator, "Invalid argument %qs for %<instanceof%>",
13589              lang_printable_name (op2_type, 0));
13590           error_found = 1;
13591         }
13592
13593       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13594         {
13595           /* If the first operand is null, the result is always false */
13596           if (op1 == null_pointer_node)
13597             return boolean_false_node;
13598           else if (flag_emit_class_files)
13599             {
13600               TREE_OPERAND (node, 1) = op2_type;
13601               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13602               return node;
13603             }
13604           /* Otherwise we have to invoke instance of to figure it out */
13605           else
13606             return build_instanceof (op1, op2_type);
13607         }
13608       /* There is no way the expression operand can be an instance of
13609          the type operand. This is a compile time error. */
13610       else
13611         {
13612           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13613           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13614           parse_error_context
13615             (wfl_operator, "Impossible for %qs to be instance of %qs",
13616              t1, lang_printable_name (op2_type, 0));
13617           free (t1);
13618           error_found = 1;
13619         }
13620
13621       break;
13622
13623       /* 15.21 Bitwise and Logical Operators */
13624     case BIT_AND_EXPR:
13625     case BIT_XOR_EXPR:
13626     case BIT_IOR_EXPR:
13627       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13628         /* Binary numeric promotion is performed on both operand and the
13629            expression retain that type */
13630         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13631
13632       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13633                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13634         /* The type of the bitwise operator expression is BOOLEAN */
13635         prom_type = boolean_type_node;
13636       else
13637         {
13638           if (!JINTEGRAL_TYPE_P (op1_type))
13639             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13640           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13641             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13642           TREE_TYPE (node) = error_mark_node;
13643           error_found = 1;
13644           /* Insert a break here if adding thing before the switch's
13645              break for this case */
13646         }
13647       break;
13648
13649       /* 15.22 Conditional-And Operator */
13650     case TRUTH_ANDIF_EXPR:
13651       /* 15.23 Conditional-Or Operator */
13652     case TRUTH_ORIF_EXPR:
13653       /* Operands must be of BOOLEAN type */
13654       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13655           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13656         {
13657           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13658             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13659           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13660             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13661           TREE_TYPE (node) = boolean_type_node;
13662           error_found = 1;
13663           break;
13664         }
13665       else if (integer_zerop (op1))
13666         {
13667           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13668         }
13669       else if (integer_onep (op1))
13670         {
13671           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13672         }
13673       /* The type of the conditional operators is BOOLEAN */
13674       prom_type = boolean_type_node;
13675       break;
13676
13677       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13678     case LT_EXPR:
13679     case GT_EXPR:
13680     case LE_EXPR:
13681     case GE_EXPR:
13682       /* The type of each of the operands must be a primitive numeric
13683          type */
13684       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13685         {
13686           if (!JNUMERIC_TYPE_P (op1_type))
13687             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13688           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13689             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13690           TREE_TYPE (node) = boolean_type_node;
13691           error_found = 1;
13692           break;
13693         }
13694       /* Binary numeric promotion is performed on the operands */
13695       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13696       /* The type of the relation expression is always BOOLEAN */
13697       prom_type = boolean_type_node;
13698       break;
13699
13700       /* 15.20 Equality Operator */
13701     case EQ_EXPR:
13702     case NE_EXPR:
13703       /* It's time for us to patch the strings. */
13704       if ((cn = patch_string (op1)))
13705        {
13706          op1 = cn;
13707          op1_type = TREE_TYPE (op1);
13708        }
13709       if ((cn = patch_string (op2)))
13710        {
13711          op2 = cn;
13712          op2_type = TREE_TYPE (op2);
13713        }
13714
13715       /* 15.20.1 Numerical Equality Operators == and != */
13716       /* Binary numeric promotion is performed on the operands */
13717       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13718         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13719
13720       /* 15.20.2 Boolean Equality Operators == and != */
13721       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13722           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13723         ;                       /* Nothing to do here */
13724
13725       /* 15.20.3 Reference Equality Operators == and != */
13726       /* Types have to be either references or the null type. If
13727          they're references, it must be possible to convert either
13728          type to the other by casting conversion. */
13729       else if ((op1 == null_pointer_node && op2 == null_pointer_node)
13730                || (op1 == null_pointer_node && JREFERENCE_TYPE_P (op2_type))
13731                || (JREFERENCE_TYPE_P (op1_type) && op2 == null_pointer_node)
13732                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13733                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13734                        || valid_ref_assignconv_cast_p (op2_type,
13735                                                        op1_type, 1))))
13736         ;                       /* Nothing to do here */
13737
13738       /* Else we have an error figure what can't be converted into
13739          what and report the error */
13740       else
13741         {
13742           char *t1;
13743           t1 = xstrdup (lang_printable_name (op1_type, 0));
13744           parse_error_context
13745             (wfl_operator,
13746              "Incompatible type for %qs. Can't convert %qs to %qs",
13747              operator_string (node), t1,
13748              lang_printable_name (op2_type, 0));
13749           free (t1);
13750           TREE_TYPE (node) = boolean_type_node;
13751           error_found = 1;
13752           break;
13753         }
13754       prom_type = boolean_type_node;
13755       break;
13756     default:
13757       abort ();
13758     }
13759
13760   if (error_found)
13761     return error_mark_node;
13762
13763   TREE_OPERAND (node, 0) = op1;
13764   TREE_OPERAND (node, 1) = op2;
13765   TREE_TYPE (node) = prom_type;
13766   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13767
13768   /* fold does not respect side-effect order as required for Java but not C.
13769    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13770    * bytecode.
13771    */
13772   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13773       : ! TREE_SIDE_EFFECTS (node))
13774     node = fold (node);
13775   return node;
13776 }
13777
13778 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13779    zero value, the value of CSTE comes after the valude of STRING */
13780
13781 static tree
13782 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13783 {
13784   const char *old = TREE_STRING_POINTER (cste);
13785   int old_len = TREE_STRING_LENGTH (cste);
13786   int len = old_len + string_len;
13787   char *new = alloca (len+1);
13788
13789   if (after)
13790     {
13791       memcpy (new, string, string_len);
13792       memcpy (&new [string_len], old, old_len);
13793     }
13794   else
13795     {
13796       memcpy (new, old, old_len);
13797       memcpy (&new [old_len], string, string_len);
13798     }
13799   new [len] = '\0';
13800   return build_string (len, new);
13801 }
13802
13803 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13804    new STRING_CST on success, NULL_TREE on failure.  */
13805
13806 static tree
13807 merge_string_cste (tree op1, tree op2, int after)
13808 {
13809   /* Handle two string constants right away.  */
13810   if (TREE_CODE (op2) == STRING_CST)
13811     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13812                                  TREE_STRING_LENGTH (op2), after);
13813
13814   /* Reasonable integer constant can be treated right away.  */
13815   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13816     {
13817       static const char *const boolean_true = "true";
13818       static const char *const boolean_false = "false";
13819       static const char *const null_pointer = "null";
13820       char ch[4];
13821       const char *string;
13822
13823       if (op2 == boolean_true_node)
13824         string = boolean_true;
13825       else if (op2 == boolean_false_node)
13826         string = boolean_false;
13827       else if (op2 == null_pointer_node
13828                || (integer_zerop (op2)
13829                    && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
13830         /* FIXME: null is not a compile-time constant, so it is only safe to
13831            merge if the overall expression is non-constant. However, this
13832            code always merges without checking the overall expression.  */
13833         string = null_pointer;
13834       else if (TREE_TYPE (op2) == char_type_node)
13835         {
13836           /* Convert the character into UTF-8.  */
13837           unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
13838           unsigned char *p = (unsigned char *) ch;
13839           if (0x01 <= c && c <= 0x7f)
13840             *p++ = (unsigned char) c;
13841           else if (c < 0x7ff)
13842             {
13843               *p++ = (unsigned char) (c >> 6 | 0xc0);
13844               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13845             }
13846           else
13847             {
13848               *p++ = (unsigned char) (c >> 12 | 0xe0);
13849               *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
13850               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
13851             }
13852           *p = '\0';
13853
13854           string = ch;
13855         }
13856       else
13857         string = string_convert_int_cst (op2);
13858
13859       return do_merge_string_cste (op1, string, strlen (string), after);
13860     }
13861   return NULL_TREE;
13862 }
13863
13864 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
13865    has to be a STRING_CST and the other part must be a STRING_CST or a
13866    INTEGRAL constant. Return a new STRING_CST if the operation
13867    succeed, NULL_TREE otherwise.
13868
13869    If the case we want to optimize for space, we might want to return
13870    NULL_TREE for each invocation of this routine. FIXME */
13871
13872 static tree
13873 string_constant_concatenation (tree op1, tree op2)
13874 {
13875   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
13876     {
13877       tree string, rest;
13878       int invert;
13879
13880       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
13881       rest   = (string == op1 ? op2 : op1);
13882       invert = (string == op1 ? 0 : 1 );
13883
13884       /* Walk REST, only if it looks reasonable */
13885       if (TREE_CODE (rest) != STRING_CST
13886           && !IS_CRAFTED_STRING_BUFFER_P (rest)
13887           && !JSTRING_TYPE_P (TREE_TYPE (rest))
13888           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
13889         {
13890           rest = java_complete_tree (rest);
13891           if (rest == error_mark_node)
13892             return error_mark_node;
13893           rest = fold (rest);
13894         }
13895       return merge_string_cste (string, rest, invert);
13896     }
13897   return NULL_TREE;
13898 }
13899
13900 /* Implement the `+' operator. Does static optimization if possible,
13901    otherwise create (if necessary) and append elements to a
13902    StringBuffer. The StringBuffer will be carried around until it is
13903    used for a function call or an assignment. Then toString() will be
13904    called on it to turn it into a String object. */
13905
13906 static tree
13907 build_string_concatenation (tree op1, tree op2)
13908 {
13909   tree result;
13910   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13911
13912   /* Try to do some static optimization */
13913   if ((result = string_constant_concatenation (op1, op2)))
13914     return result;
13915
13916   /* Discard empty strings on either side of the expression */
13917   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
13918     {
13919       op1 = op2;
13920       op2 = NULL_TREE;
13921     }
13922   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
13923     op2 = NULL_TREE;
13924
13925   /* If operands are string constant, turn then into object references */
13926   if (TREE_CODE (op1) == STRING_CST)
13927     op1 = patch_string_cst (op1);
13928   if (op2 && TREE_CODE (op2) == STRING_CST)
13929     op2 = patch_string_cst (op2);
13930
13931   /* If either one of the constant is null and the other non null
13932      operand is a String constant, return it. */
13933   if ((TREE_CODE (op1) == STRING_CST) && !op2)
13934     return op1;
13935
13936   /* If OP1 isn't already a StringBuffer, create and
13937      initialize a new one */
13938   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
13939     {
13940       /* Two solutions here:
13941          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
13942          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
13943       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
13944         op1 = BUILD_STRING_BUFFER (op1);
13945       else
13946         {
13947           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
13948           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
13949         }
13950     }
13951
13952   if (op2)
13953     {
13954       /* OP1 is no longer the last node holding a crafted StringBuffer */
13955       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
13956       /* Create a node for `{new...,xxx}.append (op2)' */
13957       op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
13958     }
13959
13960   /* Mark the last node holding a crafted StringBuffer */
13961   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
13962
13963   TREE_SIDE_EFFECTS (op1) = side_effects;
13964   return op1;
13965 }
13966
13967 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
13968    StringBuffer. If no string were found to be patched, return
13969    NULL. */
13970
13971 static tree
13972 patch_string (tree node)
13973 {
13974   if (node == error_mark_node)
13975     return error_mark_node;
13976   if (TREE_CODE (node) == STRING_CST)
13977     return patch_string_cst (node);
13978   else if (IS_CRAFTED_STRING_BUFFER_P (node))
13979     {
13980       int saved = ctxp->explicit_constructor_p;
13981       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
13982       tree ret;
13983       /* Temporary disable forbid the use of `this'. */
13984       ctxp->explicit_constructor_p = 0;
13985       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
13986       /* String concatenation arguments must be evaluated in order too. */
13987       ret = force_evaluation_order (ret);
13988       /* Restore it at its previous value */
13989       ctxp->explicit_constructor_p = saved;
13990       return ret;
13991     }
13992   return NULL_TREE;
13993 }
13994
13995 /* Build the internal representation of a string constant.  */
13996
13997 static tree
13998 patch_string_cst (tree node)
13999 {
14000   int location;
14001   if (! flag_emit_class_files)
14002     {
14003       node = get_identifier (TREE_STRING_POINTER (node));
14004       location = alloc_name_constant (CONSTANT_String, node);
14005       node = build_ref_from_constant_pool (location);
14006     }
14007   TREE_CONSTANT (node) = 1;
14008   TREE_INVARIANT (node) = 1;
14009
14010   /* ??? Guessing that the class file code can't handle casts.  */
14011   if (! flag_emit_class_files)
14012     node = convert (string_ptr_type_node, node);
14013   else
14014     TREE_TYPE (node) = string_ptr_type_node;
14015
14016   return node;
14017 }
14018
14019 /* Build an incomplete unary operator expression. */
14020
14021 static tree
14022 build_unaryop (int op_token, int op_location, tree op1)
14023 {
14024   enum tree_code op;
14025   tree unaryop;
14026   switch (op_token)
14027     {
14028     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
14029     case MINUS_TK: op = NEGATE_EXPR; break;
14030     case NEG_TK: op = TRUTH_NOT_EXPR; break;
14031     case NOT_TK: op = BIT_NOT_EXPR; break;
14032     default: abort ();
14033     }
14034
14035   unaryop = build1 (op, NULL_TREE, op1);
14036   TREE_SIDE_EFFECTS (unaryop) = 1;
14037   /* Store the location of the operator, for better error report. The
14038      string of the operator will be rebuild based on the OP value. */
14039   EXPR_WFL_LINECOL (unaryop) = op_location;
14040   return unaryop;
14041 }
14042
14043 /* Special case for the ++/-- operators, since they require an extra
14044    argument to build, which is set to NULL and patched
14045    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
14046
14047 static tree
14048 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
14049 {
14050   static const enum tree_code lookup [2][2] =
14051     {
14052       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
14053       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
14054     };
14055   tree node = build2 (lookup [is_post_p][(op_token - DECR_TK)],
14056                       NULL_TREE, op1, NULL_TREE);
14057   TREE_SIDE_EFFECTS (node) = 1;
14058   /* Store the location of the operator, for better error report. The
14059      string of the operator will be rebuild based on the OP value. */
14060   EXPR_WFL_LINECOL (node) = op_location;
14061   return node;
14062 }
14063
14064 /* Build an incomplete cast operator, based on the use of the
14065    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
14066    set. java_complete_tree is trained to walk a CONVERT_EXPR even
14067    though its type is already set.  */
14068
14069 static tree
14070 build_cast (int location, tree type, tree exp)
14071 {
14072   tree node = build1 (CONVERT_EXPR, type, exp);
14073   EXPR_WFL_LINECOL (node) = location;
14074   return node;
14075 }
14076
14077 /* Build an incomplete class reference operator.  */
14078 static tree
14079 build_incomplete_class_ref (int location, tree class_name)
14080 {
14081   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
14082   tree class_decl = GET_CPC ();
14083   tree this_class = TREE_TYPE (class_decl);
14084
14085   /* Generate the synthetic static method `class$'.  (Previously we
14086      deferred this, causing different method tables to be emitted
14087      for native code and bytecode.)  */
14088   if (!TYPE_DOT_CLASS (this_class)
14089       && !JPRIMITIVE_TYPE_P (class_name)
14090       && !(TREE_CODE (class_name) == VOID_TYPE))
14091     {
14092       tree cpc_list = GET_CPC_LIST();
14093       tree cpc = cpc_list;
14094       tree target_class;
14095
14096       /* For inner classes, add a 'class$' method to their outermost
14097          context, creating it if necessary.  */
14098
14099       while (GET_NEXT_ENCLOSING_CPC(cpc))
14100         cpc = GET_NEXT_ENCLOSING_CPC(cpc);
14101       class_decl = TREE_VALUE (cpc);
14102
14103       target_class = TREE_TYPE (class_decl);
14104
14105       if (CLASS_INTERFACE (TYPE_NAME (target_class)))
14106         {
14107           /* For interfaces, adding a static 'class$' method directly
14108              is illegal.  So create an inner class to contain the new
14109              method.  Empirically this matches the behavior of javac.  */
14110           tree t, inner;
14111           /* We want the generated inner class inside the outermost class. */
14112           GET_CPC_LIST() = cpc;
14113           t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
14114           inner = create_anonymous_class (t);
14115           target_class = TREE_TYPE (inner);
14116           end_class_declaration (1);
14117           GET_CPC_LIST() = cpc_list;
14118         }
14119
14120       if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
14121         build_dot_class_method (target_class);
14122
14123       if (this_class != target_class)
14124         TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
14125     }
14126
14127   EXPR_WFL_LINECOL (node) = location;
14128   return node;
14129 }
14130
14131 /* Complete an incomplete class reference operator.  */
14132 static tree
14133 patch_incomplete_class_ref (tree node)
14134 {
14135   tree type = TREE_OPERAND (node, 0);
14136   tree ref_type;
14137
14138   if (!(ref_type = resolve_type_during_patch (type)))
14139     return error_mark_node;
14140
14141   /* If we're not emitting class files and we know ref_type is a
14142      compiled class, build a direct reference.  */
14143   if ((! flag_emit_class_files && is_compiled_class (ref_type))
14144       || JPRIMITIVE_TYPE_P (ref_type)
14145       || TREE_CODE (ref_type) == VOID_TYPE)
14146     {
14147       tree dot = build_class_ref (ref_type);
14148       /* A class referenced by `foo.class' is initialized.  */
14149       if (!flag_emit_class_files)
14150        dot = build_class_init (ref_type, dot);
14151       return java_complete_tree (dot);
14152     }
14153
14154   /* If we're emitting class files and we have to deal with non
14155      primitive types, we invoke the synthetic static method `class$'.  */
14156   ref_type = build_dot_class_method_invocation (current_class, ref_type);
14157   return java_complete_tree (ref_type);
14158 }
14159
14160 /* 15.14 Unary operators. We return error_mark_node in case of error,
14161    but preserve the type of NODE if the type is fixed.  */
14162
14163 static tree
14164 patch_unaryop (tree node, tree wfl_op)
14165 {
14166   tree op = TREE_OPERAND (node, 0);
14167   tree op_type = TREE_TYPE (op);
14168   tree prom_type = NULL_TREE, value, decl;
14169   int outer_field_flag = 0;
14170   int code = TREE_CODE (node);
14171   int error_found = 0;
14172
14173   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14174
14175   switch (code)
14176     {
14177       /* 15.13.2 Postfix Increment Operator ++ */
14178     case POSTINCREMENT_EXPR:
14179       /* 15.13.3 Postfix Increment Operator -- */
14180     case POSTDECREMENT_EXPR:
14181       /* 15.14.1 Prefix Increment Operator ++ */
14182     case PREINCREMENT_EXPR:
14183       /* 15.14.2 Prefix Decrement Operator -- */
14184     case PREDECREMENT_EXPR:
14185       op = decl = extract_field_decl (op);
14186       outer_field_flag = outer_field_expanded_access_p (op, NULL, NULL, NULL);
14187       /* We might be trying to change an outer field accessed using
14188          access method. */
14189       if (outer_field_flag)
14190         {
14191           /* Retrieve the decl of the field we're trying to access. We
14192              do that by first retrieving the function we would call to
14193              access the field. It has been already verified that this
14194              field isn't final */
14195           if (flag_emit_class_files)
14196             decl = TREE_OPERAND (op, 0);
14197           else
14198             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14199           decl = DECL_FUNCTION_ACCESS_DECL (decl);
14200         }
14201       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14202       else if (!JDECL_P (decl)
14203           && TREE_CODE (decl) != COMPONENT_REF
14204           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14205           && TREE_CODE (decl) != INDIRECT_REF
14206           && !(TREE_CODE (decl) == COMPOUND_EXPR
14207                && TREE_OPERAND (decl, 1)
14208                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14209         {
14210           TREE_TYPE (node) = error_mark_node;
14211           error_found = 1;
14212         }
14213
14214       /* From now on, we know that op if a variable and that it has a
14215          valid wfl. We use wfl_op to locate errors related to the
14216          ++/-- operand. */
14217       if (!JNUMERIC_TYPE_P (op_type))
14218         {
14219           parse_error_context
14220             (wfl_op, "Invalid argument type %qs to %qs",
14221              lang_printable_name (op_type, 0), operator_string (node));
14222           TREE_TYPE (node) = error_mark_node;
14223           error_found = 1;
14224         }
14225       else
14226         {
14227           /* Before the addition, binary numeric promotion is performed on
14228              both operands, if really necessary */
14229           if (JINTEGRAL_TYPE_P (op_type))
14230             {
14231               value = build_int_cst (op_type, 1);
14232               TREE_TYPE (node) = op_type;
14233             }
14234           else
14235             {
14236               value = build_int_cst (NULL_TREE, 1);
14237               TREE_TYPE (node) =
14238                 binary_numeric_promotion (op_type,
14239                                           TREE_TYPE (value), &op, &value);
14240             }
14241
14242           /* We remember we might be accessing an outer field */
14243           if (outer_field_flag)
14244             {
14245               /* We re-generate an access to the field */
14246               value = build2 (PLUS_EXPR, TREE_TYPE (op),
14247                               build_outer_field_access (wfl_op, decl), value);
14248
14249               /* And we patch the original access$() into a write
14250                  with plus_op as a rhs */
14251               return outer_field_access_fix (node, op, value);
14252             }
14253
14254           /* And write back into the node. */
14255           TREE_OPERAND (node, 0) = op;
14256           TREE_OPERAND (node, 1) = value;
14257           /* Convert the overall back into its original type, if
14258              necessary, and return */
14259           if (JINTEGRAL_TYPE_P (op_type))
14260             return fold (node);
14261           else
14262             return fold (convert (op_type, node));
14263         }
14264       break;
14265
14266       /* 15.14.3 Unary Plus Operator + */
14267     case UNARY_PLUS_EXPR:
14268       /* 15.14.4 Unary Minus Operator - */
14269     case NEGATE_EXPR:
14270       if (!JNUMERIC_TYPE_P (op_type))
14271         {
14272           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14273           TREE_TYPE (node) = error_mark_node;
14274           error_found = 1;
14275         }
14276       /* Unary numeric promotion is performed on operand */
14277       else
14278         {
14279           op = do_unary_numeric_promotion (op);
14280           prom_type = TREE_TYPE (op);
14281           if (code == UNARY_PLUS_EXPR)
14282             return fold (op);
14283         }
14284       break;
14285
14286       /* 15.14.5 Bitwise Complement Operator ~ */
14287     case BIT_NOT_EXPR:
14288       if (!JINTEGRAL_TYPE_P (op_type))
14289         {
14290           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14291           TREE_TYPE (node) = error_mark_node;
14292           error_found = 1;
14293         }
14294       else
14295         {
14296           op = do_unary_numeric_promotion (op);
14297           prom_type = TREE_TYPE (op);
14298         }
14299       break;
14300
14301       /* 15.14.6 Logical Complement Operator ! */
14302     case TRUTH_NOT_EXPR:
14303       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14304         {
14305           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14306           /* But the type is known. We will report an error if further
14307              attempt of a assignment is made with this rhs */
14308           TREE_TYPE (node) = boolean_type_node;
14309           error_found = 1;
14310         }
14311       else
14312         prom_type = boolean_type_node;
14313       break;
14314
14315       /* 15.15 Cast Expression */
14316     case CONVERT_EXPR:
14317       value = patch_cast (node, wfl_operator);
14318       if (value == error_mark_node)
14319         {
14320           /* If this cast is part of an assignment, we tell the code
14321              that deals with it not to complain about a mismatch,
14322              because things have been cast, anyways */
14323           TREE_TYPE (node) = error_mark_node;
14324           error_found = 1;
14325         }
14326       else
14327         {
14328           value = fold (value);
14329           return value;
14330         }
14331       break;
14332     }
14333
14334   if (error_found)
14335     return error_mark_node;
14336
14337   /* There are cases where node has been replaced by something else
14338      and we don't end up returning here: UNARY_PLUS_EXPR,
14339      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14340   TREE_OPERAND (node, 0) = fold (op);
14341   TREE_TYPE (node) = prom_type;
14342   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14343   return fold (node);
14344 }
14345
14346 /* Generic type resolution that sometimes takes place during node
14347    patching. Returned the resolved type or generate an error
14348    message. Return the resolved type or NULL_TREE.  */
14349
14350 static tree
14351 resolve_type_during_patch (tree type)
14352 {
14353   if (unresolved_type_p (type, NULL))
14354     {
14355       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14356       if (!type_decl)
14357         {
14358           parse_error_context (type,
14359                                "Class %qs not found in type declaration",
14360                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14361           return NULL_TREE;
14362         }
14363
14364       check_deprecation (type, type_decl);
14365
14366       return TREE_TYPE (type_decl);
14367     }
14368   return type;
14369 }
14370
14371 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14372    found. Otherwise NODE or something meant to replace it is returned.  */
14373
14374 static tree
14375 patch_cast (tree node, tree wfl_op)
14376 {
14377   tree op = TREE_OPERAND (node, 0);
14378   tree cast_type = TREE_TYPE (node);
14379   tree patched, op_type;
14380   char *t1;
14381
14382   /* Some string patching might be necessary at this stage */
14383   if ((patched = patch_string (op)))
14384     TREE_OPERAND (node, 0) = op = patched;
14385   op_type = TREE_TYPE (op);
14386
14387   /* First resolve OP_TYPE if unresolved */
14388   if (!(cast_type = resolve_type_during_patch (cast_type)))
14389     return error_mark_node;
14390
14391   /* Check on cast that are proven correct at compile time */
14392   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14393     {
14394       /* Same type */
14395       if (cast_type == op_type)
14396         return node;
14397
14398       /* A narrowing conversion from a floating-point number to an
14399          integral type requires special handling (5.1.3).  */
14400       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14401         if (cast_type != long_type_node)
14402           op = convert (integer_type_node, op);
14403
14404       /* Try widening/narrowing conversion.  Potentially, things need
14405          to be worked out in gcc so we implement the extreme cases
14406          correctly.  fold_convert() needs to be fixed.  */
14407       return convert (cast_type, op);
14408     }
14409
14410   /* It's also valid to cast a boolean into a boolean */
14411   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14412     return node;
14413
14414   /* null can be casted to references */
14415   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14416     return build_null_of_type (cast_type);
14417
14418   /* The remaining legal casts involve conversion between reference
14419      types. Check for their compile time correctness. */
14420   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14421       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14422     {
14423       TREE_TYPE (node) = promote_type (cast_type);
14424       /* Now, the case can be determined correct at compile time if
14425          OP_TYPE can be converted into CAST_TYPE by assignment
14426          conversion (5.2) */
14427
14428       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14429         {
14430           TREE_SET_CODE (node, NOP_EXPR);
14431           return node;
14432         }
14433
14434       if (flag_emit_class_files)
14435         {
14436           TREE_SET_CODE (node, CONVERT_EXPR);
14437           return node;
14438         }
14439
14440       /* The cast requires a run-time check */
14441       return build3 (CALL_EXPR, promote_type (cast_type),
14442                      build_address_of (soft_checkcast_node),
14443                      tree_cons (NULL_TREE, build_class_ref (cast_type),
14444                                 build_tree_list (NULL_TREE, op)),
14445                      NULL_TREE);
14446     }
14447
14448   /* Any other casts are proven incorrect at compile time */
14449   t1 = xstrdup (lang_printable_name (op_type, 0));
14450   parse_error_context (wfl_op, "Invalid cast from %qs to %qs",
14451                        t1, lang_printable_name (cast_type, 0));
14452   free (t1);
14453   return error_mark_node;
14454 }
14455
14456 /* Build a null constant and give it the type TYPE.  */
14457
14458 static tree
14459 build_null_of_type (tree type)
14460 {
14461   tree node = build_int_cst (promote_type (type), 0);
14462   return node;
14463 }
14464
14465 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14466    a list of indices. */
14467 static tree
14468 build_array_ref (int location, tree array, tree index)
14469 {
14470   tree node = build4 (ARRAY_REF, NULL_TREE, array, index,
14471                       NULL_TREE, NULL_TREE);
14472   EXPR_WFL_LINECOL (node) = location;
14473   return node;
14474 }
14475
14476 /* 15.12 Array Access Expression */
14477
14478 static tree
14479 patch_array_ref (tree node)
14480 {
14481   tree array = TREE_OPERAND (node, 0);
14482   tree array_type  = TREE_TYPE (array);
14483   tree index = TREE_OPERAND (node, 1);
14484   tree index_type = TREE_TYPE (index);
14485   int error_found = 0;
14486
14487   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14488
14489   if (TREE_CODE (array_type) == POINTER_TYPE)
14490     array_type = TREE_TYPE (array_type);
14491
14492   /* The array reference must be an array */
14493   if (!TYPE_ARRAY_P (array_type))
14494     {
14495       parse_error_context
14496         (wfl_operator,
14497          "%<[]%> can only be applied to arrays. It can't be applied to %qs",
14498          lang_printable_name (array_type, 0));
14499       TREE_TYPE (node) = error_mark_node;
14500       error_found = 1;
14501     }
14502
14503   /* The array index undergoes unary numeric promotion. The promoted
14504      type must be int */
14505   index = do_unary_numeric_promotion (index);
14506   if (TREE_TYPE (index) != int_type_node)
14507     {
14508       if (valid_cast_to_p (index_type, int_type_node))
14509         parse_error_context (wfl_operator,
14510    "Incompatible type for %<[]%>. Explicit cast needed to convert %qs to %<int%>",
14511                              lang_printable_name (index_type, 0));
14512       else
14513         parse_error_context (wfl_operator,
14514           "Incompatible type for %<[]%>. Can't convert %qs to %<int%>",
14515                              lang_printable_name (index_type, 0));
14516       TREE_TYPE (node) = error_mark_node;
14517       error_found = 1;
14518     }
14519
14520   if (error_found)
14521     return error_mark_node;
14522
14523   array_type = TYPE_ARRAY_ELEMENT (array_type);
14524
14525   if (flag_emit_class_files)
14526     {
14527       TREE_OPERAND (node, 0) = array;
14528       TREE_OPERAND (node, 1) = index;
14529     }
14530   else
14531     node = build_java_arrayaccess (array, array_type, index);
14532   TREE_TYPE (node) = array_type;
14533   return node;
14534 }
14535
14536 /* 15.9 Array Creation Expressions */
14537
14538 static tree
14539 build_newarray_node (tree type, tree dims, int extra_dims)
14540 {
14541   tree node = build3 (NEW_ARRAY_EXPR, NULL_TREE, type,
14542                       nreverse (dims),
14543                       build_int_cst (NULL_TREE, extra_dims));
14544   return node;
14545 }
14546
14547 static tree
14548 patch_newarray (tree node)
14549 {
14550   tree type = TREE_OPERAND (node, 0);
14551   tree dims = TREE_OPERAND (node, 1);
14552   tree cdim, array_type;
14553   int error_found = 0;
14554   int ndims = 0;
14555   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14556
14557   /* Dimension types are verified. It's better for the types to be
14558      verified in order. */
14559   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14560     {
14561       int dim_error = 0;
14562       tree dim = TREE_VALUE (cdim);
14563
14564       /* Dim might have been saved during its evaluation */
14565       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14566
14567       /* The type of each specified dimension must be an integral type. */
14568       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14569         dim_error = 1;
14570
14571       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14572          promoted type must be int. */
14573       else
14574         {
14575           dim = do_unary_numeric_promotion (dim);
14576           if (TREE_TYPE (dim) != int_type_node)
14577             dim_error = 1;
14578         }
14579
14580       /* Report errors on types here */
14581       if (dim_error)
14582         {
14583           parse_error_context
14584             (TREE_PURPOSE (cdim),
14585              "Incompatible type for dimension in array creation expression. %s convert %qs to %<int%>",
14586              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14587               "Explicit cast needed to" : "Can't"),
14588              lang_printable_name (TREE_TYPE (dim), 0));
14589           error_found = 1;
14590         }
14591
14592       TREE_PURPOSE (cdim) = NULL_TREE;
14593     }
14594
14595   /* Resolve array base type if unresolved */
14596   if (!(type = resolve_type_during_patch (type)))
14597     error_found = 1;
14598
14599   if (error_found)
14600     {
14601       /* We don't want further evaluation of this bogus array creation
14602          operation */
14603       TREE_TYPE (node) = error_mark_node;
14604       return error_mark_node;
14605     }
14606
14607   /* Set array_type to the actual (promoted) array type of the result. */
14608   if (TREE_CODE (type) == RECORD_TYPE)
14609     type = build_pointer_type (type);
14610   while (--xdims >= 0)
14611     {
14612       type = promote_type (build_java_array_type (type, -1));
14613     }
14614   dims = nreverse (dims);
14615   array_type = type;
14616   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14617     {
14618       type = array_type;
14619       array_type
14620         = build_java_array_type (type,
14621                                  TREE_CODE (cdim) == INTEGER_CST
14622                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14623                                  : -1);
14624       array_type = promote_type (array_type);
14625     }
14626   dims = nreverse (dims);
14627
14628   /* The node is transformed into a function call. Things are done
14629      differently according to the number of dimensions. If the number
14630      of dimension is equal to 1, then the nature of the base type
14631      (primitive or not) matters. */
14632   if (ndims == 1)
14633     return build_new_array (type, TREE_VALUE (dims));
14634
14635   /* Can't reuse what's already written in expr.c because it uses the
14636      JVM stack representation. Provide a build_multianewarray. FIXME */
14637   return build3 (CALL_EXPR, array_type,
14638                  build_address_of (soft_multianewarray_node),
14639                  tree_cons (NULL_TREE,
14640                             build_class_ref (TREE_TYPE (array_type)),
14641                             tree_cons (NULL_TREE,
14642                                        build_int_cst (NULL_TREE, ndims),
14643                                        dims)),
14644                  NULL_TREE);
14645 }
14646
14647 /* 10.6 Array initializer.  */
14648
14649 /* Build a wfl for array element that don't have one, so we can
14650    pin-point errors.  */
14651
14652 static tree
14653 maybe_build_array_element_wfl (tree node)
14654 {
14655   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14656     {
14657       /* FIXME - old code used "prev_lc.line" and "elc.prev_col */
14658       return build_expr_wfl (NULL_TREE,
14659 #ifdef USE_MAPPED_LOCATION
14660                              input_location
14661 #else
14662                              ctxp->filename,
14663                              ctxp->lexer->token_start.line,
14664                              ctxp->lexer->token_start.col
14665 #endif
14666                              );
14667     }
14668   else
14669     return NULL_TREE;
14670 }
14671
14672 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14673    identification of initialized arrays easier to detect during walk
14674    and expansion.  */
14675
14676 static tree
14677 build_new_array_init (int location, tree values)
14678 {
14679   tree constructor = build_constructor (NULL_TREE, values);
14680   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14681   EXPR_WFL_LINECOL (to_return) = location;
14682   return to_return;
14683 }
14684
14685 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14686    occurred.  Otherwise return NODE after having set its type
14687    appropriately.  */
14688
14689 static tree
14690 patch_new_array_init (tree type, tree node)
14691 {
14692   int error_seen = 0;
14693   tree current, element_type;
14694   HOST_WIDE_INT length;
14695   int all_constant = 1;
14696   tree init = TREE_OPERAND (node, 0);
14697
14698   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14699     {
14700       parse_error_context (node,
14701                            "Invalid array initializer for non-array type %qs",
14702                            lang_printable_name (type, 1));
14703       return error_mark_node;
14704     }
14705   type = TREE_TYPE (type);
14706   element_type = TYPE_ARRAY_ELEMENT (type);
14707
14708   CONSTRUCTOR_ELTS (init) = nreverse (CONSTRUCTOR_ELTS (init));
14709
14710   for (length = 0, current = CONSTRUCTOR_ELTS (init);
14711        current;  length++, current = TREE_CHAIN (current))
14712     {
14713       tree elt = TREE_VALUE (current);
14714       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14715         {
14716           error_seen |= array_constructor_check_entry (element_type, current);
14717           elt = TREE_VALUE (current);
14718           /* When compiling to native code, STRING_CST is converted to
14719              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14720           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14721             all_constant = 0;
14722         }
14723       else
14724         {
14725           TREE_VALUE (current) = patch_new_array_init (element_type, elt);
14726           TREE_PURPOSE (current) = NULL_TREE;
14727           all_constant = 0;
14728         }
14729       if (elt && TREE_CODE (elt) == TREE_LIST
14730           && TREE_VALUE (elt) == error_mark_node)
14731         error_seen = 1;
14732     }
14733
14734   if (error_seen)
14735     return error_mark_node;
14736
14737   /* Create a new type. We can't reuse the one we have here by
14738      patching its dimension because it originally is of dimension -1
14739      hence reused by gcc. This would prevent triangular arrays. */
14740   type = build_java_array_type (element_type, length);
14741   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14742   TREE_TYPE (node) = promote_type (type);
14743   TREE_CONSTANT (init) = all_constant;
14744   TREE_INVARIANT (init) = all_constant;
14745   TREE_CONSTANT (node) = all_constant;
14746   TREE_INVARIANT (node) = all_constant;
14747   return node;
14748 }
14749
14750 /* Verify that one entry of the initializer element list can be
14751    assigned to the array base type. Report 1 if an error occurred, 0
14752    otherwise.  */
14753
14754 static int
14755 array_constructor_check_entry (tree type, tree entry)
14756 {
14757   char *array_type_string = NULL;       /* For error reports */
14758   tree value, type_value, new_value, wfl_value, patched;
14759   int error_seen = 0;
14760
14761   new_value = NULL_TREE;
14762   wfl_value = TREE_VALUE (entry);
14763
14764   value = java_complete_tree (TREE_VALUE (entry));
14765   /* patch_string return error_mark_node if arg is error_mark_node */
14766   if ((patched = patch_string (value)))
14767     value = patched;
14768   if (value == error_mark_node)
14769     return 1;
14770
14771   type_value = TREE_TYPE (value);
14772
14773   /* At anytime, try_builtin_assignconv can report a warning on
14774      constant overflow during narrowing. */
14775   SET_WFL_OPERATOR (wfl_operator, TREE_PURPOSE (entry), wfl_value);
14776   new_value = try_builtin_assignconv (wfl_operator, type, value);
14777   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14778     type_value = promote_type (type);
14779
14780   /* Check and report errors */
14781   if (!new_value)
14782     {
14783       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14784                    "Can't" : "Explicit cast needed to");
14785       if (!array_type_string)
14786         array_type_string = xstrdup (lang_printable_name (type, 1));
14787       parse_error_context
14788         (wfl_operator, "Incompatible type for array. %s convert %qs to %qs",
14789          msg, lang_printable_name (type_value, 1), array_type_string);
14790       error_seen = 1;
14791     }
14792
14793   if (new_value)
14794     TREE_VALUE (entry) = new_value;
14795
14796   if (array_type_string)
14797     free (array_type_string);
14798
14799   TREE_PURPOSE (entry) = NULL_TREE;
14800   return error_seen;
14801 }
14802
14803 static tree
14804 build_this (int location)
14805 {
14806   tree node = build_wfl_node (this_identifier_node);
14807   TREE_SET_CODE (node, THIS_EXPR);
14808   EXPR_WFL_LINECOL (node) = location;
14809   return node;
14810 }
14811
14812 /* 14.15 The return statement. It builds a modify expression that
14813    assigns the returned value to the RESULT_DECL that hold the value
14814    to be returned. */
14815
14816 static tree
14817 build_return (int location, tree op)
14818 {
14819   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
14820   EXPR_WFL_LINECOL (node) = location;
14821   node = build_debugable_stmt (location, node);
14822   return node;
14823 }
14824
14825 static tree
14826 patch_return (tree node)
14827 {
14828   tree return_exp = TREE_OPERAND (node, 0);
14829   tree meth = current_function_decl;
14830   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
14831   int error_found = 0;
14832
14833   TREE_TYPE (node) = error_mark_node;
14834   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14835
14836   /* It's invalid to have a return value within a function that is
14837      declared with the keyword void or that is a constructor */
14838   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
14839     error_found = 1;
14840
14841   /* It's invalid to use a return statement in a static block */
14842   if (DECL_CLINIT_P (current_function_decl))
14843     error_found = 1;
14844
14845   /* It's invalid to have a no return value within a function that
14846      isn't declared with the keyword `void' */
14847   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
14848     error_found = 2;
14849
14850   if (DECL_INSTINIT_P (current_function_decl))
14851     error_found = 1;
14852
14853   if (error_found)
14854     {
14855       if (DECL_INSTINIT_P (current_function_decl))
14856         parse_error_context (wfl_operator,
14857                              "%<return%> inside instance initializer");
14858
14859       else if (DECL_CLINIT_P (current_function_decl))
14860         parse_error_context (wfl_operator,
14861                              "%<return%> inside static initializer");
14862
14863       else if (!DECL_CONSTRUCTOR_P (meth))
14864         {
14865           char *t = xstrdup (lang_printable_name (mtype, 0));
14866           parse_error_context (wfl_operator,
14867                                "%<return%> with%s value from %<%s %s%>",
14868                                (error_found == 1 ? "" : "out"),
14869                                t, lang_printable_name (meth, 2));
14870           free (t);
14871         }
14872       else
14873         parse_error_context (wfl_operator,
14874                              "%<return%> with value from constructor %qs",
14875                              lang_printable_name (meth, 2));
14876       return error_mark_node;
14877     }
14878
14879   /* If we have a return_exp, build a modify expression and expand
14880      it. Note: at that point, the assignment is declared valid, but we
14881      may want to carry some more hacks */
14882   if (return_exp)
14883     {
14884       tree exp = java_complete_tree (return_exp);
14885       tree modify, patched;
14886
14887       if ((patched = patch_string (exp)))
14888         exp = patched;
14889
14890       modify = build2 (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
14891       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
14892       modify = java_complete_tree (modify);
14893
14894       if (modify != error_mark_node)
14895         {
14896           TREE_SIDE_EFFECTS (modify) = 1;
14897           TREE_OPERAND (node, 0) = modify;
14898         }
14899       else
14900         return error_mark_node;
14901     }
14902   TREE_TYPE (node) = void_type_node;
14903   TREE_SIDE_EFFECTS (node) = 1;
14904   return node;
14905 }
14906
14907 /* 14.8 The if Statement */
14908
14909 static tree
14910 build_if_else_statement (int location, tree expression, tree if_body,
14911                          tree else_body)
14912 {
14913   tree node;
14914   if (!else_body)
14915     else_body = build_java_empty_stmt ();
14916   node = build3 (COND_EXPR, NULL_TREE, expression, if_body, else_body);
14917   EXPR_WFL_LINECOL (node) = location;
14918   node = build_debugable_stmt (location, node);
14919   return node;
14920 }
14921
14922 static tree
14923 patch_if_else_statement (tree node)
14924 {
14925   tree expression = TREE_OPERAND (node, 0);
14926   int can_complete_normally
14927     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
14928        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
14929
14930   TREE_TYPE (node) = error_mark_node;
14931   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14932
14933   /* The type of expression must be boolean */
14934   if (TREE_TYPE (expression) != boolean_type_node
14935       && TREE_TYPE (expression) != promoted_boolean_type_node)
14936     {
14937       parse_error_context
14938         (wfl_operator,
14939          "Incompatible type for %<if%>. Can't convert %qs to %<boolean%>",
14940          lang_printable_name (TREE_TYPE (expression), 0));
14941       return error_mark_node;
14942     }
14943
14944   TREE_TYPE (node) = void_type_node;
14945   TREE_SIDE_EFFECTS (node) = 1;
14946   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
14947   return node;
14948 }
14949
14950 /* 14.6 Labeled Statements */
14951
14952 /* Action taken when a labeled statement is parsed. a new
14953    LABELED_BLOCK_EXPR is created. No statement is attached to the
14954    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
14955
14956 static tree
14957 build_labeled_block (int location, tree label)
14958 {
14959   tree label_name ;
14960   tree label_decl, node;
14961   if (label == NULL_TREE || label == continue_identifier_node)
14962     label_name = label;
14963   else
14964     {
14965       label_name = merge_qualified_name (label_id, label);
14966       /* Issue an error if we try to reuse a label that was previously
14967          declared */
14968       if (IDENTIFIER_LOCAL_VALUE (label_name))
14969         {
14970           EXPR_WFL_LINECOL (wfl_operator) = location;
14971           parse_error_context (wfl_operator,
14972             "Declaration of %qs shadows a previous label declaration",
14973                                IDENTIFIER_POINTER (label));
14974           EXPR_WFL_LINECOL (wfl_operator) =
14975             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
14976           parse_error_context (wfl_operator,
14977             "This is the location of the previous declaration of label %qs",
14978                                IDENTIFIER_POINTER (label));
14979           java_error_count--;
14980         }
14981     }
14982
14983   label_decl = create_label_decl (label_name);
14984   node = build2 (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
14985   EXPR_WFL_LINECOL (node) = location;
14986   TREE_SIDE_EFFECTS (node) = 1;
14987   return node;
14988 }
14989
14990 /* A labeled statement LBE is attached a statement.  */
14991
14992 static tree
14993 finish_labeled_statement (tree lbe, /* Labeled block expr */
14994                           tree statement)
14995 {
14996   /* In anyways, tie the loop to its statement */
14997   LABELED_BLOCK_BODY (lbe) = statement;
14998   pop_labeled_block ();
14999   POP_LABELED_BLOCK ();
15000   return lbe;
15001 }
15002
15003 /* 14.10, 14.11, 14.12 Loop Statements */
15004
15005 /* Create an empty LOOP_EXPR and make it the last in the nested loop
15006    list. */
15007
15008 static tree
15009 build_new_loop (tree loop_body)
15010 {
15011   tree loop = build1 (LOOP_EXPR, NULL_TREE, loop_body);
15012   TREE_SIDE_EFFECTS (loop) = 1;
15013   PUSH_LOOP (loop);
15014   return loop;
15015 }
15016
15017 /* Create a loop body according to the following structure:
15018      COMPOUND_EXPR
15019        COMPOUND_EXPR            (loop main body)
15020          EXIT_EXPR              (this order is for while/for loops.
15021          LABELED_BLOCK_EXPR      the order is reversed for do loops)
15022            LABEL_DECL           (a continue occurring here branches at the
15023            BODY                  end of this labeled block)
15024        INCREMENT                (if any)
15025
15026   REVERSED, if nonzero, tells that the loop condition expr comes
15027   after the body, like in the do-while loop.
15028
15029   To obtain a loop, the loop body structure described above is
15030   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
15031
15032    LABELED_BLOCK_EXPR
15033      LABEL_DECL                   (use this label to exit the loop)
15034      LOOP_EXPR
15035        <structure described above> */
15036
15037 static tree
15038 build_loop_body (int location, tree condition, int reversed)
15039 {
15040   tree first, second, body;
15041
15042   condition = build1 (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
15043   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
15044   condition = build_debugable_stmt (location, condition);
15045   TREE_SIDE_EFFECTS (condition) = 1;
15046
15047   body = build_labeled_block (0, continue_identifier_node);
15048   first = (reversed ? body : condition);
15049   second = (reversed ? condition : body);
15050   return build2 (COMPOUND_EXPR, NULL_TREE,
15051                  build2 (COMPOUND_EXPR, NULL_TREE, first, second),
15052                  build_java_empty_stmt ());
15053 }
15054
15055 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
15056    their order) on the current loop. Unlink the current loop from the
15057    loop list.  */
15058
15059 static tree
15060 finish_loop_body (int location, tree condition, tree body, int reversed)
15061 {
15062   tree to_return = ctxp->current_loop;
15063   tree loop_body = LOOP_EXPR_BODY (to_return);
15064   if (condition)
15065     {
15066       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
15067       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
15068          The real EXIT_EXPR is one operand further. */
15069       EXPR_WFL_LINECOL (cnode) = location;
15070       if (TREE_CODE (cnode) == EXPR_WITH_FILE_LOCATION)
15071         {
15072           cnode = EXPR_WFL_NODE (cnode);
15073           /* This one is for accurate error reports */
15074           EXPR_WFL_LINECOL (cnode) = location;
15075         }
15076       TREE_OPERAND (cnode, 0) = condition;
15077     }
15078   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
15079   POP_LOOP ();
15080   return to_return;
15081 }
15082
15083 /* Tailored version of finish_loop_body for FOR loops, when FOR
15084    loops feature the condition part */
15085
15086 static tree
15087 finish_for_loop (int location, tree condition, tree update, tree body)
15088 {
15089   /* Put the condition and the loop body in place */
15090   tree loop = finish_loop_body (location, condition, body, 0);
15091   /* LOOP is the current loop which has been now popped of the loop
15092      stack.  Mark the update block as reachable and install it.  We do
15093      this because the (current interpretation of the) JLS requires
15094      that the update expression be considered reachable even if the
15095      for loop's body doesn't complete normally.  */
15096   if (update != NULL_TREE && !IS_EMPTY_STMT (update))
15097     {
15098       tree up2 = update;
15099       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
15100         up2 = EXPR_WFL_NODE (up2);
15101       /* It is possible for the update expression to be an
15102          EXPR_WFL_NODE wrapping nothing.  */
15103       if (up2 != NULL_TREE && !IS_EMPTY_STMT (up2))
15104         {
15105           /* Try to detect constraint violations.  These would be
15106              programming errors somewhere.  */
15107           if (! EXPR_P (up2) || TREE_CODE (up2) == LOOP_EXPR)
15108             abort ();
15109           SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
15110         }
15111     }
15112   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
15113   return loop;
15114 }
15115
15116 /* Try to find the loop a block might be related to. This comprises
15117    the case where the LOOP_EXPR is found as the second operand of a
15118    COMPOUND_EXPR, because the loop happens to have an initialization
15119    part, then expressed as the first operand of the COMPOUND_EXPR. If
15120    the search finds something, 1 is returned. Otherwise, 0 is
15121    returned. The search is assumed to start from a
15122    LABELED_BLOCK_EXPR's block.  */
15123
15124 static tree
15125 search_loop (tree statement)
15126 {
15127   if (TREE_CODE (statement) == LOOP_EXPR)
15128     return statement;
15129
15130   if (TREE_CODE (statement) == BLOCK)
15131     statement = BLOCK_SUBBLOCKS (statement);
15132   else
15133     return NULL_TREE;
15134
15135   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15136     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15137       statement = TREE_OPERAND (statement, 1);
15138
15139   return (TREE_CODE (statement) == LOOP_EXPR
15140           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
15141 }
15142
15143 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15144    returned otherwise.  */
15145
15146 static int
15147 labeled_block_contains_loop_p (tree block, tree loop)
15148 {
15149   if (!block)
15150     return 0;
15151
15152   if (LABELED_BLOCK_BODY (block) == loop)
15153     return 1;
15154
15155   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
15156     return 1;
15157
15158   return 0;
15159 }
15160
15161 /* If the loop isn't surrounded by a labeled statement, create one and
15162    insert LOOP as its body.  */
15163
15164 static tree
15165 patch_loop_statement (tree loop)
15166 {
15167   tree loop_label;
15168
15169   TREE_TYPE (loop) = void_type_node;
15170   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
15171     return loop;
15172
15173   loop_label = build_labeled_block (0, NULL_TREE);
15174   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15175      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15176   LABELED_BLOCK_BODY (loop_label) = loop;
15177   PUSH_LABELED_BLOCK (loop_label);
15178   return loop_label;
15179 }
15180
15181 /* 14.13, 14.14: break and continue Statements */
15182
15183 /* Build a break or a continue statement. a null NAME indicates an
15184    unlabeled break/continue statement.  */
15185
15186 static tree
15187 build_bc_statement (int location, int is_break, tree name)
15188 {
15189   tree break_continue, label_block_expr = NULL_TREE;
15190
15191   if (name)
15192     {
15193       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15194             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15195         /* Null means that we don't have a target for this named
15196            break/continue. In this case, we make the target to be the
15197            label name, so that the error can be reported accurately in
15198            patch_bc_statement. */
15199         label_block_expr = EXPR_WFL_NODE (name);
15200     }
15201   /* Unlabeled break/continue will be handled during the
15202      break/continue patch operation */
15203   break_continue = build1 (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr);
15204
15205   IS_BREAK_STMT_P (break_continue) = is_break;
15206   TREE_SIDE_EFFECTS (break_continue) = 1;
15207   EXPR_WFL_LINECOL (break_continue) = location;
15208   break_continue = build_debugable_stmt (location, break_continue);
15209   return break_continue;
15210 }
15211
15212 /* Verification of a break/continue statement. */
15213
15214 static tree
15215 patch_bc_statement (tree node)
15216 {
15217   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15218   tree labeled_block = ctxp->current_labeled_block;
15219   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15220
15221   /* Having an identifier here means that the target is unknown. */
15222   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15223     {
15224       parse_error_context (wfl_operator, "No label definition found for %qs",
15225                            IDENTIFIER_POINTER (bc_label));
15226       return error_mark_node;
15227     }
15228   if (! IS_BREAK_STMT_P (node))
15229     {
15230       /* It's a continue statement. */
15231       for (;; labeled_block = TREE_CHAIN (labeled_block))
15232         {
15233           if (labeled_block == NULL_TREE)
15234             {
15235               if (bc_label == NULL_TREE)
15236                 parse_error_context (wfl_operator,
15237                                      "%<continue%> must be in loop");
15238               else
15239                 parse_error_context
15240                   (wfl_operator, "continue label %qs does not name a loop",
15241                    IDENTIFIER_POINTER (bc_label));
15242               return error_mark_node;
15243             }
15244           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15245                == continue_identifier_node)
15246               && (bc_label == NULL_TREE
15247                   || TREE_CHAIN (labeled_block) == bc_label))
15248             {
15249               bc_label = labeled_block;
15250               break;
15251             }
15252         }
15253     }
15254   else if (!bc_label)
15255     {
15256       for (;; labeled_block = TREE_CHAIN (labeled_block))
15257         {
15258           if (labeled_block == NULL_TREE)
15259             {
15260               parse_error_context (wfl_operator,
15261                                      "%<break%> must be in loop or switch");
15262               return error_mark_node;
15263             }
15264           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15265           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15266               || search_loop (target_stmt))
15267             {
15268               bc_label = labeled_block;
15269               break;
15270             }
15271         }
15272     }
15273
15274   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15275   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15276
15277   /* Our break/continue don't return values. */
15278   TREE_TYPE (node) = void_type_node;
15279   /* Encapsulate the break within a compound statement so that it's
15280      expanded all the times by expand_expr (and not clobbered
15281      sometimes, like after a if statement) */
15282   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15283   TREE_SIDE_EFFECTS (node) = 1;
15284   return node;
15285 }
15286
15287 /* Process the exit expression belonging to a loop. Its type must be
15288    boolean.  */
15289
15290 static tree
15291 patch_exit_expr (tree node)
15292 {
15293   tree expression = TREE_OPERAND (node, 0);
15294   TREE_TYPE (node) = error_mark_node;
15295   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15296
15297   /* The type of expression must be boolean */
15298   if (TREE_TYPE (expression) != boolean_type_node)
15299     {
15300       parse_error_context
15301         (wfl_operator,
15302     "Incompatible type for loop conditional. Can't convert %qs to %<boolean%>",
15303          lang_printable_name (TREE_TYPE (expression), 0));
15304       return error_mark_node;
15305     }
15306   /* Now we know things are allright, invert the condition, fold and
15307      return */
15308   TREE_OPERAND (node, 0) =
15309     fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
15310
15311   if (! integer_zerop (TREE_OPERAND (node, 0))
15312       && ctxp->current_loop != NULL_TREE
15313       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15314     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15315   if (! integer_onep (TREE_OPERAND (node, 0)))
15316     CAN_COMPLETE_NORMALLY (node) = 1;
15317
15318
15319   TREE_TYPE (node) = void_type_node;
15320   return node;
15321 }
15322
15323 /* 14.9 Switch statement */
15324
15325 static tree
15326 patch_switch_statement (tree node)
15327 {
15328   tree se = TREE_OPERAND (node, 0), se_type;
15329   tree save, iter;
15330
15331   /* Complete the switch expression */
15332   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15333   se_type = TREE_TYPE (se);
15334   /* The type of the switch expression must be char, byte, short or
15335      int */
15336   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15337     {
15338       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15339       parse_error_context (wfl_operator,
15340           "Incompatible type for %<switch%>. Can't convert %qs to %<int%>",
15341                            lang_printable_name (se_type, 0));
15342       /* This is what java_complete_tree will check */
15343       TREE_OPERAND (node, 0) = error_mark_node;
15344       return error_mark_node;
15345     }
15346
15347   /* Save and restore the outer case label list.  */
15348   save = case_label_list;
15349   case_label_list = NULL_TREE;
15350
15351   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15352
15353   /* See if we've found a duplicate label.  We can't leave this until
15354      code generation, because in `--syntax-only' and `-C' modes we
15355      don't do ordinary code generation.  */
15356   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15357     {
15358       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15359       tree subiter;
15360       for (subiter = TREE_CHAIN (iter);
15361            subiter != NULL_TREE;
15362            subiter = TREE_CHAIN (subiter))
15363         {
15364           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15365           if (val == subval)
15366             {
15367               EXPR_WFL_LINECOL (wfl_operator)
15368                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15369               /* The case_label_list is in reverse order, so print the
15370                  outer label first.  */
15371               parse_error_context (wfl_operator, "duplicate case label: %<"
15372                                    HOST_WIDE_INT_PRINT_DEC "%>", subval);
15373               EXPR_WFL_LINECOL (wfl_operator)
15374                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15375               parse_error_context (wfl_operator, "original label is here");
15376
15377               break;
15378             }
15379         }
15380     }
15381
15382   case_label_list = save;
15383
15384   /* Ready to return */
15385   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15386     {
15387       TREE_TYPE (node) = error_mark_node;
15388       return error_mark_node;
15389     }
15390   TREE_TYPE (node) = void_type_node;
15391   TREE_SIDE_EFFECTS (node) = 1;
15392   CAN_COMPLETE_NORMALLY (node)
15393     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15394       || ! SWITCH_HAS_DEFAULT (node);
15395   return node;
15396 }
15397
15398 /* Assertions.  */
15399
15400 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15401    might be NULL_TREE.  */
15402 static tree
15403 build_assertion (
15404 #ifdef USE_MAPPED_LOCATION
15405                  source_location location,
15406 #else
15407                  int location,
15408 #endif
15409                  tree condition, tree value)
15410 {
15411   tree node;
15412   tree klass = GET_CPC ();
15413
15414   if (! enable_assertions (klass))
15415     {
15416       condition = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15417                           boolean_false_node, condition);
15418       if (value == NULL_TREE)
15419         value = build_java_empty_stmt ();
15420       return build_if_else_statement (location, condition,
15421                                       value, NULL_TREE);
15422     }
15423
15424   if (! CLASS_USES_ASSERTIONS (klass))
15425     {
15426       tree field, classdollar, id, call;
15427       tree class_type = TREE_TYPE (klass);
15428
15429       field = add_field (class_type,
15430                          get_identifier ("$assertionsDisabled"),
15431                          boolean_type_node,
15432                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15433       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15434       FIELD_SYNTHETIC (field) = 1;
15435
15436       classdollar = build_incomplete_class_ref (location, class_type);
15437
15438       /* Call CLASS.desiredAssertionStatus().  */
15439       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15440       call = build3 (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15441       call = make_qualified_primary (classdollar, call, location);
15442       TREE_SIDE_EFFECTS (call) = 1;
15443
15444       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15445          seem odd, but we do it to generate code identical to that of
15446          the JDK.  */
15447       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15448       TREE_SIDE_EFFECTS (call) = 1;
15449       DECL_INITIAL (field) = call;
15450
15451       /* Record the initializer in the initializer statement list.  */
15452       call = build2 (MODIFY_EXPR, NULL_TREE, field, call);
15453       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15454       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15455       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15456
15457       CLASS_USES_ASSERTIONS (klass) = 1;
15458     }
15459
15460   if (value != NULL_TREE)
15461     value = tree_cons (NULL_TREE, value, NULL_TREE);
15462
15463   node = build_wfl_node (get_identifier ("java"));
15464   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15465                               location);
15466   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15467                               location);
15468
15469   node = build3 (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15470   TREE_SIDE_EFFECTS (node) = 1;
15471   /* It is too early to use BUILD_THROW.  */
15472   node = build1 (THROW_EXPR, NULL_TREE, node);
15473   TREE_SIDE_EFFECTS (node) = 1;
15474
15475   /* We invert the condition; if we just put NODE as the `else' part
15476      then we generate weird-looking bytecode.  */
15477   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15478   /* Check $assertionsDisabled.  */
15479   condition
15480     = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15481               build1 (TRUTH_NOT_EXPR, NULL_TREE,
15482                       build_wfl_node (get_identifier ("$assertionsDisabled"))),
15483               condition);
15484   node = build_if_else_statement (location, condition, node, NULL_TREE);
15485   return node;
15486 }
15487
15488 /* 14.18 The try/catch statements */
15489
15490 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15491    catches TYPE and executes CATCH_STMTS.  */
15492
15493 static tree
15494 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15495                             tree catch_stmts)
15496 {
15497   tree try_block, catch_clause_param, catch_block, catch;
15498
15499   /* First build a try block */
15500   try_block = build_expr_block (try_stmts, NULL_TREE);
15501
15502   /* Build a catch block: we need a catch clause parameter */
15503   if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15504     {
15505       tree catch_type = obtain_incomplete_type (type_or_name);
15506       jdep *dep;
15507       catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15508       register_incomplete_type (JDEP_VARIABLE, type_or_name,
15509                                 catch_clause_param, catch_type);
15510       dep = CLASSD_LAST (ctxp->classd_list);
15511       JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15512     }
15513   else
15514     catch_clause_param = build_decl (VAR_DECL, wpv_id,
15515                                      build_pointer_type (type_or_name));
15516
15517   /* And a block */
15518   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15519
15520   /* Initialize the variable and store in the block */
15521   catch = build2 (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15522                   build0 (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15523   add_stmt_to_block (catch_block, NULL_TREE, catch);
15524
15525   /* Add the catch statements */
15526   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15527
15528   /* Now we can build a JAVA_CATCH_EXPR */
15529   catch_block = build1 (JAVA_CATCH_EXPR, NULL_TREE, catch_block);
15530
15531   return build_try_statement (location, try_block, catch_block);
15532 }
15533
15534 static tree
15535 build_try_statement (int location, tree try_block, tree catches)
15536 {
15537   tree node = build2 (TRY_EXPR, NULL_TREE, try_block, catches);
15538   EXPR_WFL_LINECOL (node) = location;
15539   return node;
15540 }
15541
15542 static tree
15543 build_try_finally_statement (int location, tree try_block, tree finally)
15544 {
15545   tree node = build2 (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15546   EXPR_WFL_LINECOL (node) = location;
15547   return node;
15548 }
15549
15550 static tree
15551 patch_try_statement (tree node)
15552 {
15553   int error_found = 0;
15554   tree try = TREE_OPERAND (node, 0);
15555   /* Exception handlers are considered in left to right order */
15556   tree catch = nreverse (TREE_OPERAND (node, 1));
15557   tree current, caught_type_list = NULL_TREE;
15558
15559   /* Check catch clauses, if any. Every time we find an error, we try
15560      to process the next catch clause. We process the catch clause before
15561      the try block so that when processing the try block we can check thrown
15562      exceptions against the caught type list. */
15563   for (current = catch; current; current = TREE_CHAIN (current))
15564     {
15565       tree carg_decl, carg_type;
15566       tree sub_current, catch_block, catch_clause;
15567       int unreachable;
15568
15569       /* At this point, the structure of the catch clause is
15570            JAVA_CATCH_EXPR              (catch node)
15571              BLOCK              (with the decl of the parameter)
15572                COMPOUND_EXPR
15573                  MODIFY_EXPR   (assignment of the catch parameter)
15574                  BLOCK          (catch clause block)
15575        */
15576       catch_clause = TREE_OPERAND (current, 0);
15577       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15578       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15579
15580       /* Catch clauses can't have more than one parameter declared,
15581          but it's already enforced by the grammar. Make sure that the
15582          only parameter of the clause statement in of class Throwable
15583          or a subclass of Throwable, but that was done earlier. The
15584          catch clause parameter type has also been resolved. */
15585
15586       /* Just make sure that the catch clause parameter type inherits
15587          from java.lang.Throwable */
15588       if (!inherits_from_p (carg_type, throwable_type_node))
15589         {
15590           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15591           parse_error_context (wfl_operator,
15592                                "Can't catch class %qs. Catch clause parameter type must be a subclass of class %<java.lang.Throwable%>",
15593                                lang_printable_name (carg_type, 0));
15594           error_found = 1;
15595           continue;
15596         }
15597
15598       /* Partial check for unreachable catch statement: The catch
15599          clause is reachable iff is no earlier catch block A in
15600          the try statement such that the type of the catch
15601          clause's parameter is the same as or a subclass of the
15602          type of A's parameter */
15603       unreachable = 0;
15604       for (sub_current = catch;
15605            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15606         {
15607           tree sub_catch_clause, decl;
15608           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15609           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15610
15611           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15612             {
15613               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15614               parse_error_context
15615                 (wfl_operator,
15616                  "%<catch%> not reached because of the catch clause at line %d",
15617                  EXPR_WFL_LINENO (sub_current));
15618               unreachable = error_found = 1;
15619               break;
15620             }
15621         }
15622       /* Complete the catch clause block */
15623       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15624       if (catch_block == error_mark_node)
15625         {
15626           error_found = 1;
15627           continue;
15628         }
15629       if (CAN_COMPLETE_NORMALLY (catch_block))
15630         CAN_COMPLETE_NORMALLY (node) = 1;
15631       TREE_OPERAND (current, 0) = catch_block;
15632
15633       if (unreachable)
15634         continue;
15635
15636       /* Things to do here: the exception must be thrown */
15637
15638       /* Link this type to the caught type list */
15639       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15640     }
15641
15642   PUSH_EXCEPTIONS (caught_type_list);
15643   if ((try = java_complete_tree (try)) == error_mark_node)
15644     error_found = 1;
15645   if (CAN_COMPLETE_NORMALLY (try))
15646     CAN_COMPLETE_NORMALLY (node) = 1;
15647   POP_EXCEPTIONS ();
15648
15649   /* Verification ends here */
15650   if (error_found)
15651     return error_mark_node;
15652
15653   TREE_OPERAND (node, 0) = try;
15654   TREE_OPERAND (node, 1) = catch;
15655   TREE_TYPE (node) = void_type_node;
15656   return node;
15657 }
15658
15659 /* 14.17 The synchronized Statement */
15660
15661 static tree
15662 patch_synchronized_statement (tree node, tree wfl_op1)
15663 {
15664   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15665   tree block = TREE_OPERAND (node, 1);
15666
15667   tree tmp, enter, exit, expr_decl, assignment;
15668
15669   if (expr == error_mark_node)
15670     {
15671       block = java_complete_tree (block);
15672       return expr;
15673     }
15674
15675   /* We might be trying to synchronize on a STRING_CST */
15676   if ((tmp = patch_string (expr)))
15677     expr = tmp;
15678
15679   /* The TYPE of expr must be a reference type */
15680   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15681     {
15682       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15683       parse_error_context (wfl_operator, "Incompatible type for %<synchronized%>. Can't convert %qs to %<java.lang.Object%>",
15684                            lang_printable_name (TREE_TYPE (expr), 0));
15685       return error_mark_node;
15686     }
15687
15688   /* Generate a try-finally for the synchronized statement, except
15689      that the handler that catches all throw exception calls
15690      _Jv_MonitorExit and then rethrow the exception.
15691      The synchronized statement is then implemented as:
15692      TRY
15693        {
15694          _Jv_MonitorEnter (expression)
15695          synchronized_block
15696          _Jv_MonitorExit (expression)
15697        }
15698      CATCH_ALL
15699        {
15700          e = _Jv_exception_info ();
15701          _Jv_MonitorExit (expression)
15702          Throw (e);
15703        } */
15704
15705   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15706   BUILD_MONITOR_ENTER (enter, expr_decl);
15707   BUILD_MONITOR_EXIT (exit, expr_decl);
15708   CAN_COMPLETE_NORMALLY (enter) = 1;
15709   CAN_COMPLETE_NORMALLY (exit) = 1;
15710   assignment = build2 (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15711   TREE_SIDE_EFFECTS (assignment) = 1;
15712   node = build2 (COMPOUND_EXPR, NULL_TREE,
15713                  build2 (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15714                  build2 (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15715   node = build_expr_block (node, expr_decl);
15716
15717   return java_complete_tree (node);
15718 }
15719
15720 /* 14.16 The throw Statement */
15721
15722 static tree
15723 patch_throw_statement (tree node, tree wfl_op1)
15724 {
15725   tree expr = TREE_OPERAND (node, 0);
15726   tree type = TREE_TYPE (expr);
15727   int unchecked_ok = 0, tryblock_throws_ok = 0;
15728
15729   /* Thrown expression must be assignable to java.lang.Throwable */
15730   if (!try_reference_assignconv (throwable_type_node, expr))
15731     {
15732       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15733       parse_error_context (wfl_operator,
15734     "Can't throw %qs; it must be a subclass of class %<java.lang.Throwable%>",
15735                            lang_printable_name (type, 0));
15736       /* If the thrown expression was a reference, we further the
15737          compile-time check. */
15738       if (!JREFERENCE_TYPE_P (type))
15739         return error_mark_node;
15740     }
15741
15742   /* At least one of the following must be true */
15743
15744   /* The type of the throw expression is a not checked exception,
15745      i.e. is a unchecked expression. */
15746   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15747
15748   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15749   /* An instance can't throw a checked exception unless that exception
15750      is explicitly declared in the `throws' clause of each
15751      constructor. This doesn't apply to anonymous classes, since they
15752      don't have declared constructors. */
15753   if (!unchecked_ok
15754       && DECL_INSTINIT_P (current_function_decl)
15755       && !ANONYMOUS_CLASS_P (current_class))
15756     {
15757       tree current;
15758       for (current = TYPE_METHODS (current_class); current;
15759            current = TREE_CHAIN (current))
15760         if (DECL_CONSTRUCTOR_P (current)
15761             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15762           {
15763             parse_error_context (wfl_operator, "Checked exception %qs can't be thrown in instance initializer (not all declared constructor are declaring it in their %<throws%> clause)",
15764                                  lang_printable_name (TREE_TYPE (expr), 0));
15765             return error_mark_node;
15766           }
15767     }
15768
15769   /* Throw is contained in a try statement and at least one catch
15770      clause can receive the thrown expression or the current method is
15771      declared to throw such an exception. Or, the throw statement is
15772      contained in a method or constructor declaration and the type of
15773      the Expression is assignable to at least one type listed in the
15774      throws clause the declaration. */
15775   if (!unchecked_ok)
15776     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15777   if (!(unchecked_ok || tryblock_throws_ok))
15778     {
15779       /* If there is a surrounding try block that has no matching
15780          clatch clause, report it first. A surrounding try block exits
15781          only if there is something after the list of checked
15782          exception thrown by the current function (if any). */
15783       if (IN_TRY_BLOCK_P ())
15784         parse_error_context (wfl_operator, "Checked exception %qs can't be caught by any of the catch clause(s) of the surrounding %<try%> block",
15785                              lang_printable_name (type, 0));
15786       /* If we have no surrounding try statement and the method doesn't have
15787          any throws, report it now. FIXME */
15788
15789       /* We report that the exception can't be throw from a try block
15790          in all circumstances but when the `throw' is inside a static
15791          block. */
15792       else if (!EXCEPTIONS_P (currently_caught_type_list)
15793                && !tryblock_throws_ok)
15794         {
15795           if (DECL_CLINIT_P (current_function_decl))
15796             parse_error_context (wfl_operator,
15797                    "Checked exception %qs can't be thrown in initializer",
15798                                  lang_printable_name (type, 0));
15799           else
15800             parse_error_context (wfl_operator,
15801                    "Checked exception %qs isn't thrown from a %<try%> block",
15802                                  lang_printable_name (type, 0));
15803         }
15804       /* Otherwise, the current method doesn't have the appropriate
15805          throws declaration */
15806       else
15807         parse_error_context (wfl_operator, "Checked exception %qs doesn't match any of current method's %<throws%> declaration(s)",
15808                              lang_printable_name (type, 0));
15809       return error_mark_node;
15810     }
15811
15812   if (! flag_emit_class_files)
15813     BUILD_THROW (node, expr);
15814
15815   return node;
15816 }
15817
15818 /* Check that exception said to be thrown by method DECL can be
15819    effectively caught from where DECL is invoked.  THIS_EXPR is the
15820    expression that computes `this' for the method call.  */
15821 static void
15822 check_thrown_exceptions (
15823 #ifdef USE_MAPPED_LOCATION
15824                          source_location location,
15825 #else
15826
15827                          int location,
15828 #endif
15829                          tree decl, tree this_expr)
15830 {
15831   tree throws;
15832   int is_array_call = 0;
15833
15834   /* Skip check within generated methods, such as access$<n>.  */
15835   if (OUTER_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
15836     return;
15837
15838   if (this_expr != NULL_TREE
15839       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
15840       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
15841     is_array_call = 1;
15842
15843   /* For all the unchecked exceptions thrown by DECL.  */
15844   for (throws = DECL_FUNCTION_THROWS (decl); throws;
15845        throws = TREE_CHAIN (throws))
15846     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
15847       {
15848         /* Suppress errors about cloning arrays.  */
15849         if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
15850           continue;
15851
15852 #ifdef USE_MAPPED_LOCATION
15853         SET_EXPR_LOCATION (wfl_operator, location);
15854 #else
15855         EXPR_WFL_LINECOL (wfl_operator) = location;
15856 #endif
15857         if (DECL_FINIT_P (current_function_decl))
15858           parse_error_context
15859             (wfl_operator, "Exception %qs can't be thrown in initializer",
15860              lang_printable_name (TREE_VALUE (throws), 0));
15861         else
15862           {
15863             parse_error_context
15864               (wfl_operator, "Exception %qs must be caught, or it must be declared in the %<throws%> clause of %qs",
15865                lang_printable_name (TREE_VALUE (throws), 0),
15866                (DECL_INIT_P (current_function_decl) ?
15867                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
15868                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
15869           }
15870       }
15871 }
15872
15873 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
15874    try-catch blocks, OR is listed in the `throws' clause of the
15875    current method.  */
15876
15877 static int
15878 check_thrown_exceptions_do (tree exception)
15879 {
15880   tree list = currently_caught_type_list;
15881   resolve_and_layout (exception, NULL_TREE);
15882   /* First, all the nested try-catch-finally at that stage. The
15883      last element contains `throws' clause exceptions, if any. */
15884   if (IS_UNCHECKED_EXCEPTION_P (exception))
15885     return 1;
15886   while (list)
15887     {
15888       tree caught;
15889       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
15890         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
15891           return 1;
15892       list = TREE_CHAIN (list);
15893     }
15894   return 0;
15895 }
15896
15897 static void
15898 purge_unchecked_exceptions (tree mdecl)
15899 {
15900   tree throws = DECL_FUNCTION_THROWS (mdecl);
15901   tree new = NULL_TREE;
15902
15903   while (throws)
15904     {
15905       tree next = TREE_CHAIN (throws);
15906       if (!IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (throws)))
15907         {
15908           TREE_CHAIN (throws) = new;
15909           new = throws;
15910         }
15911       throws = next;
15912     }
15913   /* List is inverted here, but it doesn't matter */
15914   DECL_FUNCTION_THROWS (mdecl) = new;
15915 }
15916
15917 /* This function goes over all of CLASS_TYPE ctors and checks whether
15918    each of them features at least one unchecked exception in its
15919    `throws' clause. If it's the case, it returns `true', `false'
15920    otherwise.  */
15921
15922 static bool
15923 ctors_unchecked_throws_clause_p (tree class_type)
15924 {
15925   tree current;
15926
15927   for (current = TYPE_METHODS (class_type); current;
15928        current = TREE_CHAIN (current))
15929     {
15930       bool ctu = false; /* Ctor Throws Unchecked */
15931       if (DECL_CONSTRUCTOR_P (current))
15932         {
15933           tree throws;
15934           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
15935                throws = TREE_CHAIN (throws))
15936             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
15937               ctu = true;
15938         }
15939       /* We return false as we found one ctor that is unfit. */
15940       if (!ctu && DECL_CONSTRUCTOR_P (current))
15941         return false;
15942     }
15943   /* All ctors feature at least one unchecked exception in their
15944      `throws' clause. */
15945   return true;
15946 }
15947
15948 /* 15.24 Conditional Operator ?: */
15949
15950 static tree
15951 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
15952 {
15953   tree cond = TREE_OPERAND (node, 0);
15954   tree op1 = TREE_OPERAND (node, 1);
15955   tree op2 = TREE_OPERAND (node, 2);
15956   tree resulting_type = NULL_TREE;
15957   tree t1, t2, patched;
15958   int error_found = 0;
15959
15960   /* The condition and operands of ?: might be StringBuffers crafted
15961      as a result of a string concatenation.  Obtain decent ones here.  */
15962   if ((patched = patch_string (cond)))
15963     TREE_OPERAND (node, 0) = cond = patched;
15964   if ((patched = patch_string (op1)))
15965     TREE_OPERAND (node, 1) = op1 = patched;
15966   if ((patched = patch_string (op2)))
15967     TREE_OPERAND (node, 2) = op2 = patched;
15968
15969   t1 = TREE_TYPE (op1);
15970   t2 = TREE_TYPE (op2);
15971
15972   /* The first expression must be a boolean */
15973   if (TREE_TYPE (cond) != boolean_type_node)
15974     {
15975       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
15976       parse_error_context (wfl_operator,
15977                "Incompatible type for %<?:%>. Can't convert %qs to %<boolean%>",
15978                            lang_printable_name (TREE_TYPE (cond), 0));
15979       error_found = 1;
15980     }
15981
15982   /* Second and third can be numeric, boolean (i.e. primitive),
15983      references or null. Anything else results in an error */
15984   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
15985         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
15986             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
15987         || (t1 == boolean_type_node && t2 == boolean_type_node)))
15988     error_found = 1;
15989
15990   /* Determine the type of the conditional expression. Same types are
15991      easy to deal with */
15992   else if (t1 == t2)
15993     resulting_type = t1;
15994
15995   /* There are different rules for numeric types */
15996   else if (JNUMERIC_TYPE_P (t1))
15997     {
15998       /* if byte/short found, the resulting type is short */
15999       if ((t1 == byte_type_node && t2 == short_type_node)
16000           || (t1 == short_type_node && t2 == byte_type_node))
16001         resulting_type = short_type_node;
16002
16003       /* If t1 is a constant int and t2 is of type byte, short or char
16004          and t1's value fits in t2, then the resulting type is t2 */
16005       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
16006           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
16007         resulting_type = t2;
16008
16009       /* If t2 is a constant int and t1 is of type byte, short or char
16010          and t2's value fits in t1, then the resulting type is t1 */
16011       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
16012           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
16013         resulting_type = t1;
16014
16015       /* Otherwise, binary numeric promotion is applied and the
16016          resulting type is the promoted type of operand 1 and 2 */
16017       else
16018         resulting_type = binary_numeric_promotion (t1, t2,
16019                                                    &TREE_OPERAND (node, 1),
16020                                                    &TREE_OPERAND (node, 2));
16021     }
16022
16023   /* Cases of a reference and a null type */
16024   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
16025     resulting_type = t1;
16026
16027   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
16028     resulting_type = t2;
16029
16030   /* Last case: different reference types. If a type can be converted
16031      into the other one by assignment conversion, the latter
16032      determines the type of the expression */
16033   else if ((resulting_type = try_reference_assignconv (t1, op2)))
16034     resulting_type = promote_type (t1);
16035
16036   else if ((resulting_type = try_reference_assignconv (t2, op1)))
16037     resulting_type = promote_type (t2);
16038
16039   /* If we don't have any resulting type, we're in trouble */
16040   if (!resulting_type)
16041     {
16042       char *t = xstrdup (lang_printable_name (t1, 0));
16043       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
16044       parse_error_context (wfl_operator,
16045                  "Incompatible type for %<?:%>. Can't convert %qs to %qs",
16046                            t, lang_printable_name (t2, 0));
16047       free (t);
16048       error_found = 1;
16049     }
16050
16051   if (error_found)
16052     {
16053       TREE_TYPE (node) = error_mark_node;
16054       return error_mark_node;
16055     }
16056
16057   TREE_TYPE (node) = resulting_type;
16058   TREE_SET_CODE (node, COND_EXPR);
16059   CAN_COMPLETE_NORMALLY (node) = 1;
16060   return node;
16061 }
16062
16063 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
16064
16065 static tree
16066 maybe_build_class_init_for_field (tree decl, tree expr)
16067 {
16068   tree clas = DECL_CONTEXT (decl);
16069   if (flag_emit_class_files)
16070     return expr;
16071
16072   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
16073       && FIELD_FINAL (decl))
16074     {
16075       tree init = DECL_INITIAL (decl);
16076       if (init != NULL_TREE)
16077         init = fold_constant_for_init (init, decl);
16078       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
16079         return expr;
16080     }
16081
16082   return build_class_init (clas, expr);
16083 }
16084
16085 /* Try to constant fold NODE.
16086    If NODE is not a constant expression, return NULL_EXPR.
16087    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
16088
16089 static tree
16090 fold_constant_for_init (tree node, tree context)
16091 {
16092   tree op0, op1, val;
16093   enum tree_code code = TREE_CODE (node);
16094
16095   switch (code)
16096     {
16097     case INTEGER_CST:
16098       if (node == null_pointer_node)
16099         return NULL_TREE;
16100     case STRING_CST:
16101     case REAL_CST:
16102       return node;
16103
16104     case PLUS_EXPR:
16105     case MINUS_EXPR:
16106     case MULT_EXPR:
16107     case TRUNC_MOD_EXPR:
16108     case RDIV_EXPR:
16109     case LSHIFT_EXPR:
16110     case RSHIFT_EXPR:
16111     case URSHIFT_EXPR:
16112     case BIT_AND_EXPR:
16113     case BIT_XOR_EXPR:
16114     case BIT_IOR_EXPR:
16115     case TRUTH_ANDIF_EXPR:
16116     case TRUTH_ORIF_EXPR:
16117     case EQ_EXPR:
16118     case NE_EXPR:
16119     case GT_EXPR:
16120     case GE_EXPR:
16121     case LT_EXPR:
16122     case LE_EXPR:
16123       op0 = TREE_OPERAND (node, 0);
16124       op1 = TREE_OPERAND (node, 1);
16125       val = fold_constant_for_init (op0, context);
16126       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16127         return NULL_TREE;
16128       TREE_OPERAND (node, 0) = val;
16129       val = fold_constant_for_init (op1, context);
16130       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16131         return NULL_TREE;
16132       TREE_OPERAND (node, 1) = val;
16133       return patch_binop (node, op0, op1);
16134
16135     case UNARY_PLUS_EXPR:
16136     case NEGATE_EXPR:
16137     case TRUTH_NOT_EXPR:
16138     case BIT_NOT_EXPR:
16139     case CONVERT_EXPR:
16140       op0 = TREE_OPERAND (node, 0);
16141       val = fold_constant_for_init (op0, context);
16142       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16143         return NULL_TREE;
16144       TREE_OPERAND (node, 0) = val;
16145       val = patch_unaryop (node, op0);
16146       if (! TREE_CONSTANT (val))
16147         return NULL_TREE;
16148       return val;
16149
16150       break;
16151
16152     case COND_EXPR:
16153       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
16154       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16155         return NULL_TREE;
16156       TREE_OPERAND (node, 0) = val;
16157       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
16158       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16159         return NULL_TREE;
16160       TREE_OPERAND (node, 1) = val;
16161       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
16162       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16163         return NULL_TREE;
16164       TREE_OPERAND (node, 2) = val;
16165       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 1)
16166         : TREE_OPERAND (node, 2);
16167
16168     case VAR_DECL:
16169     case FIELD_DECL:
16170       if (! FIELD_FINAL (node)
16171           || DECL_INITIAL (node) == NULL_TREE)
16172         return NULL_TREE;
16173       val = DECL_INITIAL (node);
16174       /* Guard against infinite recursion. */
16175       DECL_INITIAL (node) = NULL_TREE;
16176       val = fold_constant_for_init (val, node);
16177       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
16178         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
16179       DECL_INITIAL (node) = val;
16180       return val;
16181
16182     case EXPR_WITH_FILE_LOCATION:
16183       /* Compare java_complete_tree and resolve_expression_name. */
16184       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
16185           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
16186         {
16187           tree name = EXPR_WFL_NODE (node);
16188           tree decl;
16189           if (PRIMARY_P (node))
16190             return NULL_TREE;
16191           else if (! QUALIFIED_P (name))
16192             {
16193               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
16194               if (decl == NULL_TREE
16195                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16196                 return NULL_TREE;
16197               return fold_constant_for_init (decl, decl);
16198             }
16199           else
16200             {
16201               tree r = NULL_TREE;
16202               /* Install the proper context for the field resolution.  */
16203               tree saved_current_class = current_class;
16204               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
16205               current_class = DECL_CONTEXT (context);
16206               qualify_ambiguous_name (node);
16207               r = resolve_field_access (node, &decl, NULL);
16208               /* Restore prior context.  */
16209               current_class = saved_current_class;
16210               if (r != error_mark_node && decl != NULL_TREE)
16211                 return fold_constant_for_init (decl, decl);
16212               return NULL_TREE;
16213             }
16214         }
16215       else
16216         {
16217           op0 = TREE_OPERAND (node, 0);
16218           val = fold_constant_for_init (op0, context);
16219           if (val == NULL_TREE || ! TREE_CONSTANT (val))
16220             return NULL_TREE;
16221           TREE_OPERAND (node, 0) = val;
16222           return val;
16223         }
16224
16225 #ifdef USE_COMPONENT_REF
16226     case IDENTIFIER:
16227     case COMPONENT_REF:
16228       ?;
16229 #endif
16230
16231     default:
16232       return NULL_TREE;
16233     }
16234 }
16235
16236 #ifdef USE_COMPONENT_REF
16237 /* Context is 'T' for TypeName, 'P' for PackageName,
16238    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16239
16240 tree
16241 resolve_simple_name (tree name, int context)
16242 {
16243 }
16244
16245 tree
16246 resolve_qualified_name (tree name, int context)
16247 {
16248 }
16249 #endif
16250
16251 void
16252 init_src_parse (void)
16253 {
16254   /* Sanity check; we've been bit by this before.  */
16255   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16256     abort ();
16257 }
16258
16259 \f
16260
16261 /* This section deals with the functions that are called when tables
16262    recording class initialization information are traversed.  */
16263
16264 /* This function is called for each class that is known definitely
16265    initialized when a given static method was called. This function
16266    augments a compound expression (INFO) storing all assignment to
16267    initialized static class flags if a flag already existed, otherwise
16268    a new one is created.  */
16269
16270 static int
16271 emit_test_initialization (void **entry_p, void *info)
16272 {
16273   tree l = (tree) info;
16274   tree decl, init;
16275   tree key = (tree) *entry_p;
16276   tree *ite;
16277   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16278
16279   /* If we haven't found a flag and we're dealing with self registered
16280      with current_function_decl, then don't do anything. Self is
16281      always added as definitely initialized but this information is
16282      valid only if used outside the current function. */
16283   if (current_function_decl == TREE_PURPOSE (l)
16284       && java_treetreehash_find (cf_ht, key) == NULL)
16285     return true;
16286
16287   ite = java_treetreehash_new (cf_ht, key);
16288
16289   /* If we don't have a variable, create one and install it. */
16290   if (*ite == NULL)
16291     {
16292       tree block;
16293
16294       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16295       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16296       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16297       DECL_CONTEXT (decl) = current_function_decl;
16298       DECL_INITIAL (decl) = boolean_true_node;
16299       /* Don't emit any symbolic debugging info for this decl.  */
16300       DECL_IGNORED_P (decl) = 1;
16301
16302       /* The trick is to find the right context for it. */
16303       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16304       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16305       BLOCK_EXPR_DECLS (block) = decl;
16306       *ite = decl;
16307     }
16308   else
16309     decl = *ite;
16310
16311   /* Now simply augment the compound that holds all the assignments
16312      pertaining to this method invocation. */
16313   init = build2 (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16314   TREE_SIDE_EFFECTS (init) = 1;
16315   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16316   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16317
16318   return true;
16319 }
16320
16321 #ifdef __XGETTEXT__
16322 /* Depending on the version of Bison used to compile this grammar,
16323    it may issue generic diagnostics spelled "syntax error" or
16324    "parse error".  To prevent this from changing the translation
16325    template randomly, we list all the variants of this particular
16326    diagnostic here.  Translators: there is no fine distinction
16327    between diagnostics with "syntax error" in them, and diagnostics
16328    with "parse error" in them.  It's okay to give them both the same
16329    translation.  */
16330 const char d1[] = N_("syntax error");
16331 const char d2[] = N_("parse error");
16332 const char d3[] = N_("syntax error; also virtual memory exhausted");
16333 const char d4[] = N_("parse error; also virtual memory exhausted");
16334 const char d5[] = N_("syntax error: cannot back up");
16335 const char d6[] = N_("parse error: cannot back up");
16336 #endif
16337
16338 #include "gt-java-parse.h"
16339 #include "gtype-java.h"