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, 2006
   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, 51 Franklin Street, Fifth Floor,
  22 Boston, MA 02110-1301, 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 "tree-dump.h"
  76 #include "cgraph.h"
  77 #include "target.h"
  78
  79 /* Local function prototypes */
  80 static char *java_accstring_lookup (int);
  81 static const char *accessibility_string (int);
  82 static void  classitf_redefinition_error (const char *,tree, tree, tree);
  83 static void  variable_redefinition_error (tree, tree, tree, int);
  84 static tree  create_class (int, tree, tree, tree);
  85 static tree  create_interface (int, tree, tree);
  86 static void  end_class_declaration (int);
  87 static tree  find_field (tree, tree);
  88 static tree lookup_field_wrapper (tree, tree);
  89 static int   duplicate_declaration_error_p (tree, tree, tree);
  90 static void  register_fields (int, tree, tree);
  91 static tree parser_qualified_classname (tree);
  92 static int  parser_check_super (tree, tree, tree);
  93 static int  parser_check_super_interface (tree, tree, tree);
  94 static void check_modifiers_consistency (int);
  95 static tree lookup_cl (tree);
  96 static tree lookup_java_method2 (tree, tree, int);
  97 static tree method_header (int, tree, tree, tree);
  98 static void fix_method_argument_names (tree ,tree);
  99 static tree method_declarator (tree, tree);
 100 static void parse_warning_context (tree cl, const char *gmsgid, ...) ATTRIBUTE_GCC_DIAG(2,3);
 101 #ifdef USE_MAPPED_LOCATION
 102 static void issue_warning_error_from_context
 103   (source_location, const char *gmsgid, va_list *);
 104 #else
 105 static void issue_warning_error_from_context
 106   (tree, const char *gmsgid, va_list *);
 107 #endif
 108 static void parse_ctor_invocation_error (void);
 109 static tree parse_jdk1_1_error (const char *);
 110 static void complete_class_report_errors (jdep *);
 111 static int process_imports (void);
 112 static void read_import_dir (tree);
 113 static int find_in_imports_on_demand (tree, tree);
 114 static void find_in_imports (tree, tree);
 115 static bool inner_class_accessible (tree, tree);
 116 static void check_inner_class_access (tree, tree, tree);
 117 static int check_pkg_class_access (tree, tree, bool, tree);
 118 static tree resolve_package (tree, tree *, tree *);
 119 static tree resolve_class (tree, tree, tree, tree);
 120 static void declare_local_variables (int, tree, tree);
 121 static void dump_java_tree (enum tree_dump_index, tree);
 122 static void source_start_java_method (tree);
 123 static void source_end_java_method (void);
 124 static tree find_name_in_single_imports (tree);
 125 static void check_abstract_method_header (tree);
 126 static tree lookup_java_interface_method2 (tree, tree);
 127 static tree resolve_expression_name (tree, tree *);
 128 static tree maybe_create_class_interface_decl (tree, tree, tree, tree);
 129 static int check_class_interface_creation (int, int, tree, tree, tree, tree);
 130 static tree patch_method_invocation (tree, tree, tree, int, int *, tree *);
 131 static tree resolve_and_layout (tree, tree);
 132 static tree qualify_and_find (tree, tree, tree);
 133 static tree resolve_no_layout (tree, tree);
 134 static int invocation_mode (tree, int);
 135 static tree find_applicable_accessible_methods_list (int, tree, tree, tree);
 136 static void search_applicable_methods_list (int, tree, tree, tree, tree *, tree *);
 137 static tree find_most_specific_methods_list (tree, tree);
 138 static int argument_types_convertible (tree, tree);
 139 static tree patch_invoke (tree, tree, tree);
 140 static int maybe_use_access_method (int, tree *, tree *);
 141 static tree lookup_method_invoke (int, tree, tree, tree, tree);
 142 static tree register_incomplete_type (int, tree, tree, tree);
 143 static tree check_inner_circular_reference (tree, tree);
 144 static tree check_circular_reference (tree);
 145 static tree obtain_incomplete_type (tree);
 146 static tree java_complete_lhs (tree);
 147 static tree java_complete_tree (tree);
 148 static tree maybe_generate_pre_expand_clinit (tree);
 149 static int analyze_clinit_body (tree, tree);
 150 static int maybe_yank_clinit (tree);
 151 static void start_complete_expand_method (tree);
 152 static void java_complete_expand_method (tree);
 153 static void java_expand_method_bodies (tree);
 154 static int  unresolved_type_p (tree, tree *);
 155 static void create_jdep_list (struct parser_ctxt *);
 156 static tree build_expr_block (tree, tree);
 157 static tree enter_block (void);
 158 static tree exit_block (void);
 159 static tree lookup_name_in_blocks (tree);
 160 static void maybe_absorb_scoping_blocks (void);
 161 static tree build_method_invocation (tree, tree);
 162 static tree build_new_invocation (tree, tree);
 163 static tree build_assignment (int, int, tree, tree);
 164 static tree build_binop (enum tree_code, int, tree, tree);
 165 static tree patch_assignment (tree, tree);
 166 static tree patch_binop (tree, tree, tree, int);
 167 static tree build_unaryop (int, int, tree);
 168 static tree build_incdec (int, int, tree, int);
 169 static tree patch_unaryop (tree, tree);
 170 static tree build_cast (int, tree, tree);
 171 static tree build_null_of_type (tree);
 172 static tree patch_cast (tree, tree);
 173 static int valid_ref_assignconv_cast_p (tree, tree, int);
 174 static int valid_builtin_assignconv_identity_widening_p (tree, tree);
 175 static int valid_cast_to_p (tree, tree);
 176 static int valid_method_invocation_conversion_p (tree, tree);
 177 static tree try_builtin_assignconv (tree, tree, tree);
 178 static tree try_reference_assignconv (tree, tree);
 179 static tree build_unresolved_array_type (tree);
 180 static int build_type_name_from_array_name (tree, tree *);
 181 static tree build_array_from_name (tree, tree, tree, tree *);
 182 static tree build_array_ref (int, tree, tree);
 183 static tree patch_array_ref (tree);
 184 #ifdef USE_MAPPED_LOCATION
 185 static tree make_qualified_name (tree, tree, source_location);
 186 #else
 187 static tree make_qualified_name (tree, tree, int);
 188 #endif
 189 static tree merge_qualified_name (tree, tree);
 190 static tree make_qualified_primary (tree, tree, int);
 191 static int resolve_qualified_expression_name (tree, tree *, tree *, tree *);
 192 static void qualify_ambiguous_name (tree);
 193 static tree resolve_field_access (tree, tree *, tree *);
 194 static tree build_newarray_node (tree, tree, int);
 195 static tree patch_newarray (tree);
 196 static tree resolve_type_during_patch (tree);
 197 static tree build_this (int);
 198 static tree build_wfl_wrap (tree, int);
 199 static tree build_return (int, tree);
 200 static tree patch_return (tree);
 201 static tree maybe_access_field (tree, tree, tree);
 202 static int complete_function_arguments (tree);
 203 static int check_for_static_method_reference (tree, tree, tree, tree, tree);
 204 static int not_accessible_p (tree, tree, tree, int);
 205 static void check_deprecation (tree, tree);
 206 static int class_in_current_package (tree);
 207 static tree build_if_else_statement (int, tree, tree, tree);
 208 static tree patch_if_else_statement (tree);
 209 static tree add_stmt_to_block (tree, tree, tree);
 210 static tree patch_exit_expr (tree);
 211 static tree build_labeled_block (int, tree);
 212 static tree finish_labeled_statement (tree, tree);
 213 static tree build_bc_statement (int, int, tree);
 214 static tree patch_bc_statement (tree);
 215 static tree patch_loop_statement (tree);
 216 static tree build_new_loop (tree);
 217 static tree build_loop_body (int, tree, int);
 218 static tree finish_loop_body (int, tree, tree, int);
 219 static tree build_debugable_stmt (int, tree);
 220 static tree finish_for_loop (int, tree, tree, tree);
 221 static tree patch_switch_statement (tree);
 222 static tree string_constant_concatenation (tree, tree);
 223 static tree build_string_concatenation (tree, tree);
 224 static tree patch_string_cst (tree);
 225 static tree patch_string (tree);
 226 static tree encapsulate_with_try_catch (int, tree, tree, tree);
 227 #ifdef USE_MAPPED_LOCATION
 228 static tree build_assertion (source_location, tree, tree);
 229 #else
 230 static tree build_assertion (int, tree, tree);
 231 #endif
 232 static tree build_try_statement (int, tree, tree);
 233 static tree build_try_finally_statement (int, tree, tree);
 234 static tree patch_try_statement (tree);
 235 static tree patch_synchronized_statement (tree, tree);
 236 static tree patch_throw_statement (tree, tree);
 237 static void add_exception_to_throws (tree, tree);
 238 #ifdef USE_MAPPED_LOCATION
 239 static void check_thrown_exceptions (source_location, tree, tree);
 240 #else
 241 static void check_thrown_exceptions (int, tree, tree);
 242 #endif
 243 static int check_thrown_exceptions_do (tree);
 244 static bool ctors_unchecked_throws_clause_p (tree);
 245 static void check_concrete_throws_clauses (tree, tree, tree, tree);
 246 static void check_throws_clauses (tree, tree, tree);
 247 static void finish_method_declaration (tree);
 248 static tree build_super_invocation (tree);
 249 static int verify_constructor_circularity (tree, tree);
 250 static char *constructor_circularity_msg (tree, tree);
 251 static tree build_this_super_qualified_invocation (int, tree, tree, int, int);
 252 static const char *get_printable_method_name (tree);
 253 static tree patch_conditional_expr (tree, tree, tree);
 254 static tree generate_finit (tree);
 255 static tree generate_instinit (tree);
 256 static tree build_instinit_invocation (tree);
 257 static void fix_constructors (tree);
 258 static tree build_alias_initializer_parameter_list (int, tree, tree, int *);
 259 static tree craft_constructor (tree, tree);
 260 static tree get_constructor_super (tree);
 261 static tree create_artificial_method (tree, int, tree, tree, tree);
 262 static void start_artificial_method_body (tree);
 263 static void end_artificial_method_body (tree);
 264 static int check_method_redefinition (tree, tree);
 265 static int check_method_types_complete (tree);
 266 static bool hack_is_accessible_p (tree, tree);
 267 static void java_check_regular_methods (tree);
 268 static void check_interface_throws_clauses (tree, tree);
 269 static void java_check_abstract_methods (tree);
 270 static void unreachable_stmt_error (tree);
 271 static int not_accessible_field_error (tree, tree);
 272 static tree find_expr_with_wfl (tree);
 273 static void missing_return_error (tree);
 274 static tree build_new_array_init (int, tree);
 275 static tree patch_new_array_init (tree, tree);
 276 static tree maybe_build_array_element_wfl (tree);
 277 static int array_constructor_check_entry (tree, constructor_elt *);
 278 static const char *purify_type_name (const char *);
 279 static tree fold_constant_for_init (tree, tree);
 280 static jdeplist *reverse_jdep_list (struct parser_ctxt *);
 281 static void static_ref_err (tree, tree, tree);
 282 static void parser_add_interface (tree, tree, tree);
 283 static void add_superinterfaces (tree, tree);
 284 static tree jdep_resolve_class (jdep *);
 285 static int note_possible_classname (const char *, int);
 286 static void java_complete_expand_classes (void);
 287 static void java_complete_expand_class (tree);
 288 static void java_complete_expand_methods (tree);
 289 static tree cut_identifier_in_qualified (tree);
 290 static tree java_stabilize_reference (tree);
 291 static tree do_unary_numeric_promotion (tree);
 292 static char * operator_string (tree);
 293 static tree do_merge_string_cste (tree, const char *, int, int);
 294 static tree merge_string_cste (tree, tree, int);
 295 static tree java_refold (tree);
 296 static int java_decl_equiv (tree, tree);
 297 static int binop_compound_p (enum tree_code);
 298 static tree search_loop (tree);
 299 static int labeled_block_contains_loop_p (tree, tree);
 300 static int check_abstract_method_definitions (int, tree, tree);
 301 static void java_check_abstract_method_definitions (tree);
 302 static void java_debug_context_do (int);
 303 static void java_parser_context_push_initialized_field (void);
 304 static void java_parser_context_pop_initialized_field (void);
 305 static tree reorder_static_initialized (tree);
 306 static void java_parser_context_suspend (void);
 307 static void java_parser_context_resume (void);
 308 static int pop_current_osb (struct parser_ctxt *);
 309
 310 /* JDK 1.1 work. FIXME */
 311
 312 static tree maybe_make_nested_class_name (tree);
 313 static int make_nested_class_name (tree);
 314 static void link_nested_class_to_enclosing (void);
 315 static tree resolve_inner_class (tree, tree, tree, tree);
 316 static tree find_as_inner_class (tree, tree, tree);
 317 static tree find_as_inner_class_do (tree, tree);
 318 static int check_inner_class_redefinition (tree, tree);
 319
 320 static tree build_thisn_assign (void);
 321 static tree build_current_thisn (tree);
 322 static tree build_access_to_thisn (tree, tree, int);
 323 static tree maybe_build_thisn_access_method (tree);
 324
 325 static tree build_nested_field_access (tree, tree);
 326 static tree build_nested_field_access_methods (tree);
 327 static tree build_nested_field_access_method (tree, tree, tree, tree, tree);
 328 static tree build_nested_field_access_expr (int, tree, tree, tree, tree);
 329 static tree build_nested_method_access_method (tree);
 330 static tree build_new_access_id (void);
 331
 332 static int nested_member_access_p (tree, tree);
 333 static int nested_field_expanded_access_p (tree, tree *, tree *, tree *);
 334 static tree nested_field_access_fix (tree, tree, tree);
 335
 336 static tree build_incomplete_class_ref (int, tree);
 337 static tree patch_incomplete_class_ref (tree);
 338 static tree create_anonymous_class (tree);
 339 static void patch_anonymous_class (tree, tree, tree);
 340 static void add_inner_class_fields (tree, tree);
 341
 342 static tree build_dot_class_method (tree);
 343 static tree build_dot_class_method_invocation (tree, tree);
 344 static void create_new_parser_context (int);
 345 static tree maybe_build_class_init_for_field (tree, tree);
 346
 347 static int emit_test_initialization (void **, void *);
 348
 349 static char *string_convert_int_cst (tree);
 350
 351 /* Number of error found so far. */
 352 int java_error_count;
 353 /* Number of warning found so far. */
 354 int java_warning_count;
 355 /* Cyclic inheritance report, as it can be set by layout_class */
 356 const char *cyclic_inheritance_report;
 357
 358 /* The current parser context */
 359 struct parser_ctxt *ctxp;
 360
 361 /* List of things that were analyzed for which code will be generated */
 362 struct parser_ctxt *ctxp_for_generation = NULL;
 363 struct parser_ctxt *ctxp_for_generation_last = 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 /* Hold THIS for the scope of the current method decl.  */
 411 static GTY(()) tree current_this;
 412
 413 /* Hold a list of catch clauses list. The first element of this list is
 414    the list of the catch clauses of the currently analyzed try block. */
 415 static GTY(()) tree currently_caught_type_list;
 416
 417 /* This holds a linked list of all the case labels for the current
 418    switch statement.  It is only used when checking to see if there
 419    are duplicate labels.  FIXME: probably this should just be attached
 420    to the switch itself; then it could be referenced via
 421    `ctxp->current_loop'.  */
 422 static GTY(()) tree case_label_list;
 423
 424 /* Anonymous class counter. Will be reset to 1 every time a non
 425    anonymous class gets created. */
 426 static int anonymous_class_counter = 1;
 427
 428 static GTY(()) tree src_parse_roots[1];
 429
 430 /* All classes seen from source code */
 431 #define gclass_list src_parse_roots[0]
 432
 433 /* Check modifiers. If one doesn't fit, retrieve it in its declaration
 434    line and point it out.  */
 435 /* Should point out the one that don't fit. ASCII/unicode, going
 436    backward. FIXME */
 437
 438 #define check_modifiers(__message, __value, __mask) do {        \
 439   if ((__value) & ~(__mask))                                    \
 440     {                                                           \
 441       size_t i, remainder = (__value) & ~(__mask);              \
 442       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)     \
 443         if ((1 << i) & remainder)                               \
 444           parse_error_context (ctxp->modifier_ctx [i], (__message), \
 445                                java_accstring_lookup (1 << i)); \
 446     }                                                           \
 447 } while (0)
 448
 449 %}
 450
 451 %union {
 452   tree node;
 453   int sub_token;
 454   struct {
 455     int token;
 456 #ifdef USE_MAPPED_LOCATION
 457     source_location location;
 458 #else
 459     int location;
 460 #endif
 461   } operator;
 462   int value;
 463 }
 464
 465 %{
 466 #ifdef USE_MAPPED_LOCATION
 467 #define SET_EXPR_LOCATION_FROM_TOKEN(EXPR, TOKEN) \
 468   SET_EXPR_LOCATION(EXPR, (TOKEN).location)
 469 #else
 470 #define SET_EXPR_LOCATION_FROM_TOKEN(EXPR, TOKEN) \
 471   (EXPR_WFL_LINECOL (EXPR) = (TOKEN).location)
 472 #endif
 473
 474 #include "lex.c"
 475 %}
 476
 477 %pure_parser
 478
 479 /* Things defined here have to match the order of what's in the
 480    binop_lookup table.  */
 481
 482 %token   PLUS_TK         MINUS_TK        MULT_TK         DIV_TK    REM_TK
 483 %token   LS_TK           SRS_TK          ZRS_TK
 484 %token   AND_TK          XOR_TK          OR_TK
 485 %token   BOOL_AND_TK BOOL_OR_TK
 486 %token   EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
 487
 488 /* This maps to the same binop_lookup entry than the token above */
 489
 490 %token   PLUS_ASSIGN_TK  MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
 491 %token   REM_ASSIGN_TK
 492 %token   LS_ASSIGN_TK    SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 493 %token   AND_ASSIGN_TK   XOR_ASSIGN_TK   OR_ASSIGN_TK
 494
 495
 496 /* Modifier TOKEN have to be kept in this order. Don't scramble it */
 497
 498 %token   PUBLIC_TK       PRIVATE_TK         PROTECTED_TK
 499 %token   STATIC_TK       FINAL_TK           SYNCHRONIZED_TK
 500 %token   VOLATILE_TK     TRANSIENT_TK       NATIVE_TK
 501 %token   PAD_TK          ABSTRACT_TK        STRICT_TK
 502 %token   MODIFIER_TK
 503
 504 /* Keep those two in order, too */
 505 %token   DECR_TK INCR_TK
 506
 507 /* From now one, things can be in any order */
 508
 509 %token   DEFAULT_TK      IF_TK              THROW_TK
 510 %token   BOOLEAN_TK      DO_TK              IMPLEMENTS_TK
 511 %token   THROWS_TK       BREAK_TK           IMPORT_TK
 512 %token   ELSE_TK         INSTANCEOF_TK      RETURN_TK
 513 %token   VOID_TK         CATCH_TK           INTERFACE_TK
 514 %token   CASE_TK         EXTENDS_TK         FINALLY_TK
 515 %token   SUPER_TK        WHILE_TK           CLASS_TK
 516 %token   SWITCH_TK       CONST_TK           TRY_TK
 517 %token   FOR_TK          NEW_TK             CONTINUE_TK
 518 %token   GOTO_TK         PACKAGE_TK         THIS_TK
 519 %token   ASSERT_TK
 520
 521 %token   BYTE_TK         SHORT_TK           INT_TK            LONG_TK
 522 %token   CHAR_TK         INTEGRAL_TK
 523
 524 %token   FLOAT_TK        DOUBLE_TK          FP_TK
 525
 526 %token   ID_TK
 527
 528 %token   REL_QM_TK         REL_CL_TK NOT_TK  NEG_TK
 529
 530 %token   ASSIGN_ANY_TK   ASSIGN_TK
 531 %token   OP_TK  CP_TK  OCB_TK  CCB_TK  OSB_TK  CSB_TK  SC_TK  C_TK DOT_TK
 532
 533 %token   STRING_LIT_TK   CHAR_LIT_TK        INT_LIT_TK        FP_LIT_TK
 534 %token   TRUE_TK         FALSE_TK           BOOL_LIT_TK       NULL_TK
 535
 536 %type    <value>        modifiers MODIFIER_TK final synchronized
 537
 538 %type    <node>         super ID_TK identifier
 539 %type    <node>         name simple_name qualified_name
 540 %type    <node>         type_declaration compilation_unit
 541                         field_declaration method_declaration extends_interfaces
 542                         interfaces interface_type_list
 543                         import_declarations package_declaration
 544                         type_declarations interface_body
 545                         interface_member_declaration constant_declaration
 546                         interface_member_declarations interface_type
 547                         abstract_method_declaration
 548 %type    <node>         class_body_declaration class_member_declaration
 549                         static_initializer constructor_declaration block
 550 %type    <node>         class_body_declarations constructor_header
 551 %type    <node>         class_or_interface_type class_type class_type_list
 552                         constructor_declarator explicit_constructor_invocation
 553 %type    <node>         dim_expr dim_exprs this_or_super throws
 554
 555 %type    <node>         variable_declarator_id variable_declarator
 556                         variable_declarators variable_initializer
 557                         variable_initializers constructor_body
 558                         array_initializer
 559
 560 %type    <node>         class_body block_end constructor_block_end
 561 %type    <node>         statement statement_without_trailing_substatement
 562                         labeled_statement if_then_statement label_decl
 563                         if_then_else_statement while_statement for_statement
 564                         statement_nsi labeled_statement_nsi do_statement
 565                         if_then_else_statement_nsi while_statement_nsi
 566                         for_statement_nsi statement_expression_list for_init
 567                         for_update statement_expression expression_statement
 568                         primary_no_new_array expression primary array_type
 569                         array_creation_initialized array_creation_uninitialized
 570                         class_instance_creation_expression field_access
 571                         method_invocation array_access something_dot_new
 572                         argument_list postfix_expression while_expression
 573                         post_increment_expression post_decrement_expression
 574                         unary_expression_not_plus_minus unary_expression
 575                         pre_increment_expression pre_decrement_expression
 576                         cast_expression
 577                         multiplicative_expression additive_expression
 578                         shift_expression relational_expression
 579                         equality_expression and_expression
 580                         exclusive_or_expression inclusive_or_expression
 581                         conditional_and_expression conditional_or_expression
 582                         conditional_expression assignment_expression
 583                         left_hand_side assignment for_header for_begin
 584                         constant_expression do_statement_begin empty_statement
 585                         switch_statement synchronized_statement throw_statement
 586                         try_statement assert_statement
 587                         switch_expression switch_block
 588                         catches catch_clause catch_clause_parameter finally
 589                         anonymous_class_creation trap_overflow_corner_case
 590 %type    <node>         return_statement break_statement continue_statement
 591
 592 %type    <operator>     ASSIGN_TK      MULT_ASSIGN_TK  DIV_ASSIGN_TK
 593 %type    <operator>     REM_ASSIGN_TK  PLUS_ASSIGN_TK  MINUS_ASSIGN_TK
 594 %type    <operator>     LS_ASSIGN_TK   SRS_ASSIGN_TK   ZRS_ASSIGN_TK
 595 %type    <operator>     AND_ASSIGN_TK  XOR_ASSIGN_TK   OR_ASSIGN_TK
 596 %type    <operator>     ASSIGN_ANY_TK  assignment_operator
 597 %token   <operator>     EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
 598 %token   <operator>     BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
 599 %token   <operator>     DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
 600 %token   <operator>     NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK OCB_TK CCB_TK
 601 %token   <operator>     OP_TK OSB_TK DOT_TK THROW_TK INSTANCEOF_TK
 602 %type    <operator>     THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
 603 %type    <operator>     CASE_TK DEFAULT_TK TRY_TK CATCH_TK SYNCHRONIZED_TK
 604 %type    <operator>     NEW_TK ASSERT_TK
 605
 606 %type    <node>         method_body
 607
 608 %type    <node>         literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
 609                         STRING_LIT_TK NULL_TK VOID_TK
 610
 611 %type    <node>         IF_TK WHILE_TK FOR_TK
 612
 613 %type    <node>         formal_parameter_list formal_parameter
 614                         method_declarator method_header
 615
 616 %type    <node>         primitive_type reference_type type
 617                         BOOLEAN_TK INTEGRAL_TK FP_TK
 618
 619 /* Added or modified JDK 1.1 rule types  */
 620 %type    <node>         type_literals
 621
 622 %%
 623 /* 19.2 Production from 2.3: The Syntactic Grammar  */
 624 goal:  compilation_unit
 625                 {}
 626 ;
 627
 628 /* 19.3 Productions from 3: Lexical structure  */
 629 literal:
 630         INT_LIT_TK
 631 |       FP_LIT_TK
 632 |       BOOL_LIT_TK
 633 |       CHAR_LIT_TK
 634 |       STRING_LIT_TK
 635 |       NULL_TK
 636 ;
 637
 638 /* 19.4 Productions from 4: Types, Values and Variables  */
 639 type:
 640         primitive_type
 641 |       reference_type
 642 ;
 643
 644 primitive_type:
 645         INTEGRAL_TK
 646 |       FP_TK
 647 |       BOOLEAN_TK
 648 ;
 649
 650 reference_type:
 651         class_or_interface_type
 652 |       array_type
 653 ;
 654
 655 class_or_interface_type:
 656         name
 657 ;
 658
 659 class_type:
 660         class_or_interface_type /* Default rule */
 661 ;
 662
 663 interface_type:
 664          class_or_interface_type
 665 ;
 666
 667 array_type:
 668         primitive_type dims
 669                 {
 670                   int osb = pop_current_osb (ctxp);
 671                   tree t = build_java_array_type (($1), -1);
 672                   while (--osb)
 673                     t = build_unresolved_array_type (t);
 674                   $$ = t;
 675                 }
 676 |       name dims
 677                 {
 678                   int osb = pop_current_osb (ctxp);
 679                   tree t = $1;
 680                   while (osb--)
 681                     t = build_unresolved_array_type (t);
 682                   $$ = t;
 683                 }
 684 ;
 685
 686 /* 19.5 Productions from 6: Names  */
 687 name:
 688         simple_name             /* Default rule */
 689 |       qualified_name          /* Default rule */
 690 ;
 691
 692 simple_name:
 693         identifier              /* Default rule */
 694 ;
 695
 696 qualified_name:
 697         name DOT_TK identifier
 698                 { $$ = make_qualified_name ($1, $3, $2.location); }
 699 ;
 700
 701 identifier:
 702         ID_TK
 703 ;
 704
 705 /* 19.6: Production from 7: Packages  */
 706 compilation_unit:
 707                 {$$ = NULL;}
 708 |       package_declaration
 709 |       import_declarations
 710 |       type_declarations
 711 |       package_declaration import_declarations
 712 |       package_declaration type_declarations
 713 |       import_declarations type_declarations
 714 |       package_declaration import_declarations type_declarations
 715 ;
 716
 717 import_declarations:
 718         import_declaration
 719                 {
 720                   $$ = NULL;
 721                 }
 722 |       import_declarations import_declaration
 723                 {
 724                   $$ = NULL;
 725                 }
 726 ;
 727
 728 type_declarations:
 729         type_declaration
 730 |       type_declarations type_declaration
 731 ;
 732
 733 package_declaration:
 734         PACKAGE_TK name SC_TK
 735                 {
 736                   ctxp->package = EXPR_WFL_NODE ($2);
 737                 }
 738 |       PACKAGE_TK error
 739                 {yyerror ("Missing name"); RECOVER;}
 740 |       PACKAGE_TK name error
 741                 {yyerror ("';' expected"); RECOVER;}
 742 ;
 743
 744 import_declaration:
 745         single_type_import_declaration
 746 |       type_import_on_demand_declaration
 747 ;
 748
 749 single_type_import_declaration:
 750         IMPORT_TK name SC_TK
 751                 {
 752                   tree name = EXPR_WFL_NODE ($2), last_name;
 753                   int   i = IDENTIFIER_LENGTH (name)-1;
 754                   const char *last = &IDENTIFIER_POINTER (name)[i];
 755                   while (last != IDENTIFIER_POINTER (name))
 756                     {
 757                       if (last [0] == '.')
 758                         break;
 759                       last--;
 760                     }
 761                   last_name = get_identifier (++last);
 762                   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
 763                     {
 764                       tree err = find_name_in_single_imports (last_name);
 765                       if (err && err != name)
 766                         parse_error_context
 767                           ($2, "Ambiguous class: %qs and %qs",
 768                            IDENTIFIER_POINTER (name),
 769                            IDENTIFIER_POINTER (err));
 770                       else
 771                         REGISTER_IMPORT ($2, last_name);
 772                     }
 773                   else
 774                     REGISTER_IMPORT ($2, last_name);
 775                 }
 776 |       IMPORT_TK error
 777                 {yyerror ("Missing name"); RECOVER;}
 778 |       IMPORT_TK name error
 779                 {yyerror ("';' expected"); RECOVER;}
 780 ;
 781
 782 type_import_on_demand_declaration:
 783         IMPORT_TK name DOT_TK MULT_TK SC_TK
 784                 {
 785                   tree name = EXPR_WFL_NODE ($2);
 786                   tree it;
 787                   /* Search for duplicates. */
 788                   for (it = ctxp->import_demand_list; it; it = TREE_CHAIN (it))
 789                     if (EXPR_WFL_NODE (TREE_PURPOSE (it)) == name)
 790                       break;
 791                   /* Don't import the same thing more than once, just ignore
 792                      duplicates (7.5.2) */
 793                   if (! it)
 794                     {
 795                       read_import_dir ($2);
 796                       ctxp->import_demand_list =
 797                         chainon (ctxp->import_demand_list,
 798                                  build_tree_list ($2, NULL_TREE));
 799                     }
 800                 }
 801 |       IMPORT_TK name DOT_TK error
 802                 {yyerror ("'*' expected"); RECOVER;}
 803 |       IMPORT_TK name DOT_TK MULT_TK error
 804                 {yyerror ("';' expected"); RECOVER;}
 805 ;
 806
 807 type_declaration:
 808         class_declaration
 809                 { end_class_declaration (0); }
 810 |       interface_declaration
 811                 { end_class_declaration (0); }
 812 |       empty_statement
 813 |       error
 814                 {
 815                   YYERROR_NOW;
 816                   yyerror ("Class or interface declaration expected");
 817                 }
 818 ;
 819
 820 /* 19.7 Shortened from the original:
 821    modifiers: modifier | modifiers modifier
 822    modifier: any of public...  */
 823 modifiers:
 824         MODIFIER_TK
 825                 {
 826                   $$ = (1 << $1);
 827                 }
 828 |       modifiers MODIFIER_TK
 829                 {
 830                   int acc = (1 << $2);
 831                   if ($$ & acc)
 832                     parse_error_context
 833                       (ctxp->modifier_ctx [$2], "Modifier %qs declared twice",
 834                        java_accstring_lookup (acc));
 835                   else
 836                     {
 837                       $$ |= acc;
 838                     }
 839                 }
 840 ;
 841
 842 /* 19.8.1 Production from $8.1: Class Declaration */
 843 class_declaration:
 844         modifiers CLASS_TK identifier super interfaces
 845                 { create_class ($1, $3, $4, $5); }
 846         class_body
 847                 {;}
 848 |       CLASS_TK identifier super interfaces
 849                 { create_class (0, $2, $3, $4); }
 850         class_body
 851                 {;}
 852 |       modifiers CLASS_TK error
 853                 { yyerror ("Missing class name"); RECOVER; }
 854 |       CLASS_TK error
 855                 { yyerror ("Missing class name"); RECOVER; }
 856 |       CLASS_TK identifier error
 857                 {
 858                   if (!ctxp->class_err) yyerror ("'{' expected");
 859                   DRECOVER(class1);
 860                 }
 861 |       modifiers CLASS_TK identifier error
 862                 { if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER; }
 863 ;
 864
 865 super:
 866                 { $$ = NULL; }
 867 |       EXTENDS_TK class_type
 868                 { $$ = $2; }
 869 |       EXTENDS_TK class_type error
 870                 {yyerror ("'{' expected"); ctxp->class_err=1;}
 871 |       EXTENDS_TK error
 872                 {yyerror ("Missing super class name"); ctxp->class_err=1;}
 873 ;
 874
 875 interfaces:
 876                 { $$ = NULL_TREE; }
 877 |       IMPLEMENTS_TK interface_type_list
 878                 { $$ = $2; }
 879 |       IMPLEMENTS_TK error
 880                 {
 881                   ctxp->class_err=1;
 882                   yyerror ("Missing interface name");
 883                 }
 884 ;
 885
 886 interface_type_list:
 887         interface_type
 888                 {
 889                   ctxp->interface_number = 1;
 890                   $$ = build_tree_list ($1, NULL_TREE);
 891                 }
 892 |       interface_type_list C_TK interface_type
 893                 {
 894                   ctxp->interface_number++;
 895                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
 896                 }
 897 |       interface_type_list C_TK error
 898                 {yyerror ("Missing interface name"); RECOVER;}
 899 ;
 900
 901 class_body:
 902         OCB_TK CCB_TK
 903                 {
 904                   $$ = GET_CPC ();
 905                 }
 906 |       OCB_TK class_body_declarations CCB_TK
 907                 {
 908                   $$ = GET_CPC ();
 909                 }
 910 ;
 911
 912 class_body_declarations:
 913         class_body_declaration
 914 |       class_body_declarations class_body_declaration
 915 ;
 916
 917 class_body_declaration:
 918         class_member_declaration
 919 |       static_initializer
 920 |       constructor_declaration
 921 |       block                   /* Added, JDK1.1, instance initializer */
 922                 {
 923                   if (!IS_EMPTY_STMT ($1))
 924                     {
 925                       TREE_CHAIN ($1) = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
 926                       SET_CPC_INSTANCE_INITIALIZER_STMT (ctxp, $1);
 927                     }
 928                 }
 929 ;
 930
 931 class_member_declaration:
 932         field_declaration
 933 |       method_declaration
 934 |       class_declaration       /* Added, JDK1.1 inner classes */
 935                 { end_class_declaration (1); }
 936 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
 937                 { end_class_declaration (1); }
 938 |       empty_statement
 939 ;
 940
 941 /* 19.8.2 Productions from 8.3: Field Declarations  */
 942 field_declaration:
 943         type variable_declarators SC_TK
 944                 { register_fields (0, $1, $2); }
 945 |       modifiers type variable_declarators SC_TK
 946                 {
 947                   check_modifiers
 948                     ("Illegal modifier %qs for field declaration",
 949                      $1, FIELD_MODIFIERS);
 950                   check_modifiers_consistency ($1);
 951                   register_fields ($1, $2, $3);
 952                 }
 953 ;
 954
 955 variable_declarators:
 956         /* Should we use build_decl_list () instead ? FIXME */
 957         variable_declarator     /* Default rule */
 958 |       variable_declarators C_TK variable_declarator
 959                 { $$ = chainon ($1, $3); }
 960 |       variable_declarators C_TK error
 961                 {yyerror ("Missing term"); RECOVER;}
 962 ;
 963
 964 variable_declarator:
 965         variable_declarator_id
 966                 { $$ = build_tree_list ($1, NULL_TREE); }
 967 |       variable_declarator_id ASSIGN_TK variable_initializer
 968                 {
 969                   if (java_error_count)
 970                     $3 = NULL_TREE;
 971                   $$ = build_tree_list
 972                     ($1, build_assignment ($2.token, $2.location, $1, $3));
 973                 }
 974 |       variable_declarator_id ASSIGN_TK error
 975                 {
 976                   yyerror ("Missing variable initializer");
 977                   $$ = build_tree_list ($1, NULL_TREE);
 978                   RECOVER;
 979                 }
 980 |       variable_declarator_id ASSIGN_TK variable_initializer error
 981                 {
 982                   yyerror ("';' expected");
 983                   $$ = build_tree_list ($1, NULL_TREE);
 984                   RECOVER;
 985                 }
 986 ;
 987
 988 variable_declarator_id:
 989         identifier
 990 |       variable_declarator_id OSB_TK CSB_TK
 991                 { $$ = build_unresolved_array_type ($1); }
 992 |       identifier error
 993                 {yyerror ("Invalid declaration"); DRECOVER(vdi);}
 994 |       variable_declarator_id OSB_TK error
 995                 {
 996                   yyerror ("']' expected");
 997                   DRECOVER(vdi);
 998                 }
 999 |       variable_declarator_id CSB_TK error
1000                 {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
1001 ;
1002
1003 variable_initializer:
1004         expression
1005 |       array_initializer
1006 ;
1007
1008 /* 19.8.3 Productions from 8.4: Method Declarations  */
1009 method_declaration:
1010         method_header
1011                 {
1012                   current_function_decl = $1;
1013                   if (current_function_decl
1014                       && TREE_CODE (current_function_decl) == FUNCTION_DECL)
1015                     source_start_java_method (current_function_decl);
1016                   else
1017                     current_function_decl = NULL_TREE;
1018                 }
1019         method_body
1020                 { finish_method_declaration ($3); }
1021 |       method_header error
1022                 {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
1023 ;
1024
1025 method_header:
1026         type method_declarator throws
1027                 { $$ = method_header (0, $1, $2, $3); }
1028 |       VOID_TK method_declarator throws
1029                 { $$ = method_header (0, void_type_node, $2, $3); }
1030 |       modifiers type method_declarator throws
1031                 { $$ = method_header ($1, $2, $3, $4); }
1032 |       modifiers VOID_TK method_declarator throws
1033                 { $$ = method_header ($1, void_type_node, $3, $4); }
1034 |       type error
1035                 {
1036                   yyerror ("Invalid method declaration, method name required");
1037                   $$ = NULL_TREE;
1038                   RECOVER;
1039                 }
1040 |       modifiers type error
1041                 {
1042                   yyerror ("Identifier expected");
1043                   $$ = NULL_TREE;
1044                   RECOVER;
1045                 }
1046 |       VOID_TK error
1047                 {
1048                   yyerror ("Identifier expected");
1049                   $$ = NULL_TREE;
1050                   RECOVER;
1051                 }
1052 |       modifiers VOID_TK error
1053                 {
1054                   yyerror ("Identifier expected");
1055                   $$ = NULL_TREE;
1056                   RECOVER;
1057                 }
1058 |       modifiers error
1059                 {
1060                   yyerror ("Invalid method declaration, return type required");
1061                   $$ = NULL_TREE;
1062                   RECOVER;
1063                 }
1064 ;
1065
1066 method_declarator:
1067         identifier OP_TK CP_TK
1068                 {
1069                   ctxp->formal_parameter_number = 0;
1070                   $$ = method_declarator ($1, NULL_TREE);
1071                 }
1072 |       identifier OP_TK formal_parameter_list CP_TK
1073                 { $$ = method_declarator ($1, $3); }
1074 |       method_declarator OSB_TK CSB_TK
1075                 {
1076                   SET_EXPR_LOCATION_FROM_TOKEN (wfl_operator, $2);
1077                   TREE_PURPOSE ($1) =
1078                     build_unresolved_array_type (TREE_PURPOSE ($1));
1079                   parse_warning_context
1080                     (wfl_operator,
1081                      "Discouraged form of returned type specification");
1082                 }
1083 |       identifier OP_TK error
1084                 {yyerror ("')' expected"); DRECOVER(method_declarator);}
1085 |       method_declarator OSB_TK error
1086                 {yyerror ("']' expected"); RECOVER;}
1087 ;
1088
1089 formal_parameter_list:
1090         formal_parameter
1091                 {
1092                   ctxp->formal_parameter_number = 1;
1093                 }
1094 |       formal_parameter_list C_TK formal_parameter
1095                 {
1096                   ctxp->formal_parameter_number += 1;
1097                   $$ = chainon ($1, $3);
1098                 }
1099 |       formal_parameter_list C_TK error
1100                 { yyerror ("Missing formal parameter term"); RECOVER; }
1101 ;
1102
1103 formal_parameter:
1104         type variable_declarator_id
1105                 {
1106                   $$ = build_tree_list ($2, $1);
1107                 }
1108 |       final type variable_declarator_id /* Added, JDK1.1 final parms */
1109                 {
1110                   $$ = build_tree_list ($3, $2);
1111                   ARG_FINAL_P ($$) = 1;
1112                 }
1113 |       type error
1114                 {
1115                   yyerror ("Missing identifier"); RECOVER;
1116                   $$ = NULL_TREE;
1117                 }
1118 |       final type error
1119                 {
1120                   yyerror ("Missing identifier"); RECOVER;
1121                   $$ = NULL_TREE;
1122                 }
1123 ;
1124
1125 final:
1126         modifiers
1127                 {
1128                   check_modifiers ("Illegal modifier %qs. Only %<final%> was expected here",
1129                                    $1, ACC_FINAL);
1130                   if ($1 != ACC_FINAL)
1131                     MODIFIER_WFL (FINAL_TK) = build_wfl_node (NULL_TREE);
1132                 }
1133 ;
1134
1135 throws:
1136                 { $$ = NULL_TREE; }
1137 |       THROWS_TK class_type_list
1138                 { $$ = $2; }
1139 |       THROWS_TK error
1140                 {yyerror ("Missing class type term"); RECOVER;}
1141 ;
1142
1143 class_type_list:
1144         class_type
1145                 { $$ = build_tree_list ($1, $1); }
1146 |       class_type_list C_TK class_type
1147                 { $$ = tree_cons ($3, $3, $1); }
1148 |       class_type_list C_TK error
1149                 {yyerror ("Missing class type term"); RECOVER;}
1150 ;
1151
1152 method_body:
1153         block
1154 |       SC_TK { $$ = NULL_TREE; }
1155 ;
1156
1157 /* 19.8.4 Productions from 8.5: Static Initializers  */
1158 static_initializer:
1159         static block
1160                 {
1161                   TREE_CHAIN ($2) = CPC_STATIC_INITIALIZER_STMT (ctxp);
1162                   SET_CPC_STATIC_INITIALIZER_STMT (ctxp, $2);
1163                   current_static_block = NULL_TREE;
1164                 }
1165 ;
1166
1167 static:                         /* Test lval.sub_token here */
1168         modifiers
1169                 {
1170                   check_modifiers ("Illegal modifier %qs for static initializer", $1, ACC_STATIC);
1171                   /* Can't have a static initializer in an innerclass */
1172                   if ($1 | ACC_STATIC &&
1173                       GET_CPC_LIST () && !TOPLEVEL_CLASS_DECL_P (GET_CPC ()))
1174                     parse_error_context
1175                       (MODIFIER_WFL (STATIC_TK),
1176                        "Can't define static initializer in class %qs. Static initializer can only be defined in top-level classes",
1177                        IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())));
1178                   SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
1179                 }
1180 ;
1181
1182 /* 19.8.5 Productions from 8.6: Constructor Declarations  */
1183 constructor_declaration:
1184         constructor_header
1185                 {
1186                   current_function_decl = $1;
1187                   source_start_java_method (current_function_decl);
1188                 }
1189         constructor_body
1190                 { finish_method_declaration ($3); }
1191 ;
1192
1193 constructor_header:
1194         constructor_declarator throws
1195                 { $$ = method_header (0, NULL_TREE, $1, $2); }
1196 |       modifiers constructor_declarator throws
1197                 { $$ = method_header ($1, NULL_TREE, $2, $3); }
1198 ;
1199
1200 constructor_declarator:
1201         simple_name OP_TK CP_TK
1202                 {
1203                   ctxp->formal_parameter_number = 0;
1204                   $$ = method_declarator ($1, NULL_TREE);
1205                 }
1206 |       simple_name OP_TK formal_parameter_list CP_TK
1207                 { $$ = method_declarator ($1, $3); }
1208 ;
1209
1210 constructor_body:
1211         /* Unlike regular method, we always need a complete (empty)
1212            body so we can safely perform all the required code
1213            addition (super invocation and field initialization) */
1214         block_begin constructor_block_end
1215                 {
1216                   BLOCK_EXPR_BODY ($2) = build_java_empty_stmt ();
1217                   $$ = $2;
1218                 }
1219 |       block_begin explicit_constructor_invocation constructor_block_end
1220                 { $$ = $3; }
1221 |       block_begin block_statements constructor_block_end
1222                 { $$ = $3; }
1223 |       block_begin explicit_constructor_invocation block_statements constructor_block_end
1224                 { $$ = $4; }
1225 ;
1226
1227 constructor_block_end:
1228         block_end
1229 ;
1230
1231 /* Error recovery for that rule moved down expression_statement: rule.  */
1232 explicit_constructor_invocation:
1233         this_or_super OP_TK CP_TK SC_TK
1234                 {
1235                   $$ = build_method_invocation ($1, NULL_TREE);
1236                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1237                   $$ = java_method_add_stmt (current_function_decl, $$);
1238                 }
1239 |       this_or_super OP_TK argument_list CP_TK SC_TK
1240                 {
1241                   $$ = build_method_invocation ($1, $3);
1242                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $$);
1243                   $$ = java_method_add_stmt (current_function_decl, $$);
1244                 }
1245         /* Added, JDK1.1 inner classes. Modified because the rule
1246            'primary' couldn't work.  */
1247 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
1248                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1249 |       name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
1250                 {$$ = parse_jdk1_1_error ("explicit constructor invocation"); }
1251 ;
1252
1253 this_or_super:                  /* Added, simplifies error diagnostics */
1254         THIS_TK
1255                 {
1256                   tree wfl = build_wfl_node (this_identifier_node);
1257                   SET_EXPR_LOCATION_FROM_TOKEN (wfl, $1);
1258                   $$ = wfl;
1259                 }
1260 |       SUPER_TK
1261                 {
1262                   tree wfl = build_wfl_node (super_identifier_node);
1263                   SET_EXPR_LOCATION_FROM_TOKEN (wfl, $1);
1264                   $$ = wfl;
1265                 }
1266 ;
1267
1268 /* 19.9 Productions from 9: Interfaces  */
1269 /* 19.9.1 Productions from 9.1: Interfaces Declarations  */
1270 interface_declaration:
1271         INTERFACE_TK identifier
1272                 { create_interface (0, $2, NULL_TREE); }
1273         interface_body
1274                 { ; }
1275 |       modifiers INTERFACE_TK identifier
1276                 { create_interface ($1, $3, NULL_TREE); }
1277         interface_body
1278                 { ; }
1279 |       INTERFACE_TK identifier extends_interfaces
1280                 { create_interface (0, $2, $3); }
1281         interface_body
1282                 { ; }
1283 |       modifiers INTERFACE_TK identifier extends_interfaces
1284                 { create_interface ($1, $3, $4); }
1285         interface_body
1286                 { ; }
1287 |       INTERFACE_TK identifier error
1288                 { yyerror ("'{' expected"); RECOVER; }
1289 |       modifiers INTERFACE_TK identifier error
1290                 { yyerror ("'{' expected"); RECOVER; }
1291 ;
1292
1293 extends_interfaces:
1294         EXTENDS_TK interface_type
1295                 {
1296                   ctxp->interface_number = 1;
1297                   $$ = build_tree_list ($2, NULL_TREE);
1298                 }
1299 |       extends_interfaces C_TK interface_type
1300                 {
1301                   ctxp->interface_number++;
1302                   $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
1303                 }
1304 |       EXTENDS_TK error
1305                 {yyerror ("Invalid interface type"); RECOVER;}
1306 |       extends_interfaces C_TK error
1307                 {yyerror ("Missing term"); RECOVER;}
1308 ;
1309
1310 interface_body:
1311         OCB_TK CCB_TK
1312                 { $$ = NULL_TREE; }
1313 |       OCB_TK interface_member_declarations CCB_TK
1314                 { $$ = NULL_TREE; }
1315 ;
1316
1317 interface_member_declarations:
1318         interface_member_declaration
1319 |       interface_member_declarations interface_member_declaration
1320 ;
1321
1322 interface_member_declaration:
1323         constant_declaration
1324 |       abstract_method_declaration
1325 |       class_declaration       /* Added, JDK1.1 inner classes */
1326                 { end_class_declaration (1); }
1327 |       interface_declaration   /* Added, JDK1.1 inner interfaces */
1328                 { end_class_declaration (1); }
1329 |       empty_statement
1330 ;
1331
1332 constant_declaration:
1333         field_declaration
1334 ;
1335
1336 abstract_method_declaration:
1337         method_header SC_TK
1338                 {
1339                   check_abstract_method_header ($1);
1340                   current_function_decl = NULL_TREE; /* FIXME ? */
1341                 }
1342 |       method_header error
1343                 {yyerror ("';' expected"); RECOVER;}
1344 ;
1345
1346 /* 19.10 Productions from 10: Arrays  */
1347 array_initializer:
1348         OCB_TK CCB_TK
1349                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1350 |       OCB_TK C_TK CCB_TK
1351                 { $$ = build_new_array_init ($1.location, NULL_TREE); }
1352 |       OCB_TK variable_initializers CCB_TK
1353                 { $$ = build_new_array_init ($1.location, $2); }
1354 |       OCB_TK variable_initializers C_TK CCB_TK
1355                 { $$ = build_new_array_init ($1.location, $2); }
1356 ;
1357
1358 variable_initializers:
1359         variable_initializer
1360                 {
1361                   $$ = tree_cons (maybe_build_array_element_wfl ($1),
1362                                   $1, NULL_TREE);
1363                 }
1364 |       variable_initializers C_TK variable_initializer
1365                 {
1366                   $$ = tree_cons (maybe_build_array_element_wfl ($3), $3, $1);
1367                 }
1368 |       variable_initializers C_TK error
1369                 {yyerror ("Missing term"); RECOVER;}
1370 ;
1371
1372 /* 19.11 Production from 14: Blocks and Statements  */
1373 block:
1374         block_begin block_end
1375                 { $$ = $2; }
1376 |       block_begin block_statements block_end
1377                 { $$ = $3; }
1378 ;
1379
1380 block_begin:
1381         OCB_TK
1382                 { enter_block (); }
1383 ;
1384
1385 block_end:
1386         CCB_TK
1387                 {
1388                   maybe_absorb_scoping_blocks ();
1389                   $$ = exit_block ();
1390                   if (!BLOCK_SUBBLOCKS ($$))
1391                     BLOCK_SUBBLOCKS ($$) = build_java_empty_stmt ();
1392                 }
1393 ;
1394
1395 block_statements:
1396         block_statement
1397 |       block_statements block_statement
1398 ;
1399
1400 block_statement:
1401         local_variable_declaration_statement
1402 |       statement
1403                 { java_method_add_stmt (current_function_decl, $1); }
1404 |       class_declaration       /* Added, JDK1.1 local classes */
1405                 {
1406                   LOCAL_CLASS_P (TREE_TYPE (GET_CPC ())) = 1;
1407                   end_class_declaration (1);
1408                 }
1409 ;
1410
1411 local_variable_declaration_statement:
1412         local_variable_declaration SC_TK /* Can't catch missing ';' here */
1413 ;
1414
1415 local_variable_declaration:
1416         type variable_declarators
1417                 { declare_local_variables (0, $1, $2); }
1418 |       final type variable_declarators /* Added, JDK1.1 final locals */
1419                 { declare_local_variables ($1, $2, $3); }
1420 ;
1421
1422 statement:
1423         statement_without_trailing_substatement
1424 |       labeled_statement
1425 |       if_then_statement
1426 |       if_then_else_statement
1427 |       while_statement
1428 |       for_statement
1429                 { $$ = exit_block (); }
1430 ;
1431
1432 statement_nsi:
1433         statement_without_trailing_substatement
1434 |       labeled_statement_nsi
1435 |       if_then_else_statement_nsi
1436 |       while_statement_nsi
1437 |       for_statement_nsi
1438                 { $$ = exit_block (); }
1439 ;
1440
1441 statement_without_trailing_substatement:
1442         block
1443 |       empty_statement
1444 |       expression_statement
1445 |       switch_statement
1446 |       do_statement
1447 |       break_statement
1448 |       continue_statement
1449 |       return_statement
1450 |       synchronized_statement
1451 |       throw_statement
1452 |       try_statement
1453 |       assert_statement
1454 ;
1455
1456 empty_statement:
1457         SC_TK
1458                 {
1459                   if (flag_extraneous_semicolon
1460                       && ! current_static_block
1461                       && (! current_function_decl ||
1462                           /* Verify we're not in a inner class declaration */
1463                           (GET_CPC () != TYPE_NAME
1464                            (DECL_CONTEXT (current_function_decl)))))
1465
1466                     {
1467 #ifdef USE_MAPPED_LOCATION
1468                       SET_EXPR_LOCATION (wfl_operator, input_location);
1469 #else
1470                       EXPR_WFL_SET_LINECOL (wfl_operator, input_line, -1);
1471 #endif
1472                       parse_warning_context (wfl_operator, "An empty declaration is a deprecated feature that should not be used");
1473                     }
1474                   $$ = build_java_empty_stmt ();
1475                 }
1476 ;
1477
1478 label_decl:
1479         identifier REL_CL_TK
1480                 {
1481                   $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
1482                                             EXPR_WFL_NODE ($1));
1483                   pushlevel (2);
1484                   push_labeled_block ($$);
1485                   PUSH_LABELED_BLOCK ($$);
1486                 }
1487 ;
1488
1489 labeled_statement:
1490         label_decl statement
1491                 { $$ = finish_labeled_statement ($1, $2); }
1492 |       identifier error
1493                 {yyerror ("':' expected"); RECOVER;}
1494 ;
1495
1496 labeled_statement_nsi:
1497         label_decl statement_nsi
1498                 { $$ = finish_labeled_statement ($1, $2); }
1499 ;
1500
1501 /* We concentrate here a bunch of error handling rules that we couldn't write
1502    earlier, because expression_statement catches a missing ';'.  */
1503 expression_statement:
1504         statement_expression SC_TK
1505                 {
1506                   /* We have a statement. Generate a WFL around it so
1507                      we can debug it */
1508 #ifdef USE_MAPPED_LOCATION
1509                   $$ = expr_add_location ($1, input_location, 1);
1510 #else
1511                   $$ = build_expr_wfl ($1, input_filename, input_line, 0);
1512                   JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
1513 #endif
1514                   /* We know we have a statement, so set the debug
1515                      info to be eventually generate here. */
1516                 }
1517 |       error SC_TK
1518                 {
1519                   YYNOT_TWICE yyerror ("Invalid expression statement");
1520                   DRECOVER (expr_stmt);
1521                 }
1522 |       error OCB_TK
1523                 {
1524                   YYNOT_TWICE yyerror ("Invalid expression statement");
1525                   DRECOVER (expr_stmt);
1526                 }
1527 |       error CCB_TK
1528                 {
1529                   YYNOT_TWICE yyerror ("Invalid expression statement");
1530                   DRECOVER (expr_stmt);
1531                 }
1532 |       this_or_super OP_TK error
1533                 {yyerror ("')' expected"); RECOVER;}
1534 |       this_or_super OP_TK CP_TK error
1535                 {
1536                   parse_ctor_invocation_error ();
1537                   RECOVER;
1538                 }
1539 |       this_or_super OP_TK argument_list error
1540                 {yyerror ("')' expected"); RECOVER;}
1541 |       this_or_super OP_TK argument_list CP_TK error
1542                 {
1543                   parse_ctor_invocation_error ();
1544                   RECOVER;
1545                 }
1546 |       name DOT_TK SUPER_TK error
1547                 {yyerror ("'(' expected"); RECOVER;}
1548 |       name DOT_TK SUPER_TK OP_TK error
1549                 {yyerror ("')' expected"); RECOVER;}
1550 |       name DOT_TK SUPER_TK OP_TK argument_list error
1551                 {yyerror ("')' expected"); RECOVER;}
1552 |       name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
1553                 {yyerror ("';' expected"); RECOVER;}
1554 |       name DOT_TK SUPER_TK OP_TK CP_TK error
1555                 {yyerror ("';' expected"); RECOVER;}
1556 ;
1557
1558 statement_expression:
1559         assignment
1560 |       pre_increment_expression
1561 |       pre_decrement_expression
1562 |       post_increment_expression
1563 |       post_decrement_expression
1564 |       method_invocation
1565 |       class_instance_creation_expression
1566 ;
1567
1568 if_then_statement:
1569         IF_TK OP_TK expression CP_TK statement
1570                 {
1571                   $$ = build_if_else_statement ($2.location, $3,
1572                                                 $5, NULL_TREE);
1573                 }
1574 |       IF_TK error
1575                 {yyerror ("'(' expected"); RECOVER;}
1576 |       IF_TK OP_TK error
1577                 {yyerror ("Missing term"); RECOVER;}
1578 |       IF_TK OP_TK expression error
1579                 {yyerror ("')' expected"); RECOVER;}
1580 ;
1581
1582 if_then_else_statement:
1583         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
1584                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1585 ;
1586
1587 if_then_else_statement_nsi:
1588         IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
1589                 { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
1590 ;
1591
1592 switch_statement:
1593         switch_expression
1594                 {
1595                   enter_block ();
1596                 }
1597         switch_block
1598                 {
1599                   /* Make into "proper list" of COMPOUND_EXPRs.
1600                      I.e. make the last statement also have its own
1601                      COMPOUND_EXPR. */
1602                   maybe_absorb_scoping_blocks ();
1603                   TREE_OPERAND ($1, 1) = exit_block ();
1604                   $$ = build_debugable_stmt (EXPR_WFL_LINECOL ($1), $1);
1605                 }
1606 ;
1607
1608 switch_expression:
1609         SWITCH_TK OP_TK expression CP_TK
1610                 {
1611                   $$ = build3 (SWITCH_EXPR, NULL_TREE, $3,
1612                                NULL_TREE, NULL_TREE);
1613                   SET_EXPR_LOCATION_FROM_TOKEN ($$, $2);
1614                 }
1615 |       SWITCH_TK error
1616                 {yyerror ("'(' expected"); RECOVER;}
1617 |       SWITCH_TK OP_TK error
1618                 {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
1619 |       SWITCH_TK OP_TK expression CP_TK error
1620                 {yyerror ("'{' expected"); RECOVER;}
1621 ;
1622
1623 /* Default assignment is there to avoid type node on switch_block
1624    node. */
1625
1626 switch_block:
1627         OCB_TK CCB_TK
1628                 { $$ = NULL_TREE; }
1629 |       OCB_TK switch_labels CCB_TK
1630                 { $$ = NULL_TREE; }
1631 |       OCB_TK switch_block_statement_groups CCB_TK
1632                 { $$ = NULL_TREE; }
1633 |       OCB_TK switch_block_statement_groups switch_labels CCB_TK
1634                 { $$ = NULL_TREE; }
1635 ;
1636
1637 switch_block_statement_groups:
1638         switch_block_statement_group
1639 |       switch_block_statement_groups switch_block_statement_group
1640 ;
1641
1642 switch_block_statement_group:
1643         switch_labels block_statements
1644 ;
1645
1646 switch_labels:
1647         switch_label
1648 |       switch_labels switch_label
1649 ;
1650
1651 switch_label:
1652         CASE_TK constant_expression REL_CL_TK
1653                 {
1654                   tree lab = build1 (CASE_EXPR, NULL_TREE, $2);
1655                   SET_EXPR_LOCATION_FROM_TOKEN (lab, $1);
1656                   java_method_add_stmt (current_function_decl, lab);
1657                 }
1658 |       DEFAULT_TK REL_CL_TK
1659                 {
1660                   tree lab = make_node (DEFAULT_EXPR);
1661                   SET_EXPR_LOCATION_FROM_TOKEN (lab, $1);
1662                   java_method_add_stmt (current_function_decl, lab);
1663                 }
1664 |       CASE_TK error
1665                 {yyerror ("Missing or invalid constant expression"); RECOVER;}
1666 |       CASE_TK constant_expression error
1667                 {yyerror ("':' expected"); RECOVER;}
1668 |       DEFAULT_TK error
1669                 {yyerror ("':' expected"); RECOVER;}
1670 ;
1671
1672 while_expression:
1673         WHILE_TK OP_TK expression CP_TK
1674                 {
1675                   tree body = build_loop_body ($2.location, $3, 0);
1676                   $$ = build_new_loop (body);
1677                 }
1678 ;
1679
1680 while_statement:
1681         while_expression statement
1682                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1683 |       WHILE_TK error
1684                 {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
1685 |       WHILE_TK OP_TK error
1686                 {yyerror ("Missing term and ')' expected"); RECOVER;}
1687 |       WHILE_TK OP_TK expression error
1688                 {yyerror ("')' expected"); RECOVER;}
1689 ;
1690
1691 while_statement_nsi:
1692         while_expression statement_nsi
1693                 { $$ = finish_loop_body (0, NULL_TREE, $2, 0); }
1694 ;
1695
1696 do_statement_begin:
1697         DO_TK
1698                 {
1699                   tree body = build_loop_body (0, NULL_TREE, 1);
1700                   $$ = build_new_loop (body);
1701                 }
1702         /* Need error handing here. FIXME */
1703 ;
1704
1705 do_statement:
1706         do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
1707                 { $$ = finish_loop_body ($4.location, $5, $2, 1); }
1708 ;
1709
1710 for_statement:
1711         for_begin SC_TK expression SC_TK for_update CP_TK statement
1712                 {
1713                   if (CONSTANT_CLASS_P ($3))
1714                     $3 = build_wfl_node ($3);
1715                   $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);
1716                 }
1717 |       for_begin SC_TK SC_TK for_update CP_TK statement
1718                 {
1719                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1720                   /* We have not condition, so we get rid of the EXIT_EXPR */
1721                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1722                     build_java_empty_stmt ();
1723                 }
1724 |       for_begin SC_TK error
1725                 {yyerror ("Invalid control expression"); RECOVER;}
1726 |       for_begin SC_TK expression SC_TK error
1727                 {yyerror ("Invalid update expression"); RECOVER;}
1728 |       for_begin SC_TK SC_TK error
1729                 {yyerror ("Invalid update expression"); RECOVER;}
1730 ;
1731
1732 for_statement_nsi:
1733         for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
1734                 { $$ = finish_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
1735 |       for_begin SC_TK SC_TK for_update CP_TK statement_nsi
1736                 {
1737                   $$ = finish_for_loop (0, NULL_TREE, $4, $6);
1738                   /* We have not condition, so we get rid of the EXIT_EXPR */
1739                   LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
1740                     build_java_empty_stmt ();
1741                 }
1742 ;
1743
1744 for_header:
1745         FOR_TK OP_TK
1746                 {
1747                   /* This scope defined for local variable that may be
1748                      defined within the scope of the for loop */
1749                   enter_block ();
1750                 }
1751 |       FOR_TK error
1752                 {yyerror ("'(' expected"); DRECOVER(for_1);}
1753 |       FOR_TK OP_TK error
1754                 {yyerror ("Invalid init statement"); RECOVER;}
1755 ;
1756
1757 for_begin:
1758         for_header for_init
1759                 {
1760                   /* We now declare the loop body. The loop is
1761                      declared as a for loop. */
1762                   tree body = build_loop_body (0, NULL_TREE, 0);
1763                   $$ =  build_new_loop (body);
1764                   FOR_LOOP_P ($$) = 1;
1765                   /* The loop is added to the current block the for
1766                      statement is defined within */
1767                   java_method_add_stmt (current_function_decl, $$);
1768                 }
1769 ;
1770 for_init:                       /* Can be empty */
1771                 { $$ = build_java_empty_stmt (); }
1772 |       statement_expression_list
1773                 {
1774                   /* Init statement recorded within the previously
1775                      defined block scope */
1776                   $$ = java_method_add_stmt (current_function_decl, $1);
1777                 }
1778 |       local_variable_declaration
1779                 {
1780                   /* Local variable are recorded within the previously
1781                      defined block scope */
1782                   $$ = NULL_TREE;
1783                 }
1784 |       statement_expression_list error
1785                 {yyerror ("';' expected"); DRECOVER(for_init_1);}
1786 ;
1787
1788 for_update:                     /* Can be empty */
1789                 {$$ = build_java_empty_stmt ();}
1790 |       statement_expression_list
1791                 { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
1792 ;
1793
1794 statement_expression_list:
1795         statement_expression
1796                 { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
1797 |       statement_expression_list C_TK statement_expression
1798                 { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
1799 |       statement_expression_list C_TK error
1800                 {yyerror ("Missing term"); RECOVER;}
1801 ;
1802
1803 break_statement:
1804         BREAK_TK SC_TK
1805                 { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
1806 |       BREAK_TK identifier SC_TK
1807                 { $$ = build_bc_statement ($1.location, 1, $2); }
1808 |       BREAK_TK error
1809                 {yyerror ("Missing term"); RECOVER;}
1810 |       BREAK_TK identifier error
1811                 {yyerror ("';' expected"); RECOVER;}
1812 ;
1813
1814 continue_statement:
1815         CONTINUE_TK SC_TK
1816                 { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
1817 |       CONTINUE_TK identifier SC_TK
1818                 { $$ = build_bc_statement ($1.location, 0, $2); }
1819 |       CONTINUE_TK error
1820                 {yyerror ("Missing term"); RECOVER;}
1821 |       CONTINUE_TK identifier error
1822                 {yyerror ("';' expected"); RECOVER;}
1823 ;
1824
1825 return_statement:
1826         RETURN_TK SC_TK
1827                 { $$ = build_return ($1.location, NULL_TREE); }
1828 |       RETURN_TK expression SC_TK
1829                 { $$ = build_return ($1.location, $2); }
1830 |       RETURN_TK error
1831                 {yyerror ("Missing term"); RECOVER;}
1832 |       RETURN_TK expression error
1833                 {yyerror ("';' expected"); RECOVER;}
1834 ;
1835
1836 throw_statement:
1837         THROW_TK expression SC_TK
1838                 {
1839                   $$ = build1 (THROW_EXPR, NULL_TREE, $2);
1840                   SET_EXPR_LOCATION_FROM_TOKEN ($$, $1);
1841                 }
1842 |       THROW_TK error
1843                 {yyerror ("Missing term"); RECOVER;}
1844 |       THROW_TK expression error
1845                 {yyerror ("';' expected"); RECOVER;}
1846 ;
1847
1848 assert_statement:
1849         ASSERT_TK expression REL_CL_TK expression SC_TK
1850                 {
1851                   $$ = build_assertion ($1.location, $2, $4);
1852                 }
1853 |       ASSERT_TK expression SC_TK
1854                 {
1855                   $$ = build_assertion ($1.location, $2, NULL_TREE);
1856                 }
1857 |       ASSERT_TK error
1858                 {yyerror ("Missing term"); RECOVER;}
1859 |       ASSERT_TK expression error
1860                 {yyerror ("';' expected"); RECOVER;}
1861 ;
1862
1863 synchronized_statement:
1864         synchronized OP_TK expression CP_TK block
1865                 {
1866                   $$ = build2 (SYNCHRONIZED_EXPR, NULL_TREE, $3, $5);
1867                   EXPR_WFL_LINECOL ($$) =
1868                     EXPR_WFL_LINECOL (MODIFIER_WFL (SYNCHRONIZED_TK));
1869                 }
1870 |       synchronized OP_TK expression CP_TK error
1871                 {yyerror ("'{' expected"); RECOVER;}
1872 |       synchronized error
1873                 {yyerror ("'(' expected"); RECOVER;}
1874 |       synchronized OP_TK error CP_TK
1875                 {yyerror ("Missing term"); RECOVER;}
1876 |       synchronized OP_TK error
1877                 {yyerror ("Missing term"); RECOVER;}
1878 ;
1879
1880 synchronized:
1881         modifiers
1882                 {
1883                   check_modifiers (
1884              "Illegal modifier %qs. Only %<synchronized%> was expected here",
1885                                    $1, ACC_SYNCHRONIZED);
1886                   if ($1 != ACC_SYNCHRONIZED)
1887                     MODIFIER_WFL (SYNCHRONIZED_TK) =
1888                       build_wfl_node (NULL_TREE);
1889                 }
1890 ;
1891
1892 try_statement:
1893         TRY_TK block catches
1894                 { $$ = build_try_statement ($1.location, $2, $3); }
1895 |       TRY_TK block finally
1896                 { $$ = build_try_finally_statement ($1.location, $2, $3); }
1897 |       TRY_TK block catches finally
1898                 { $$ = build_try_finally_statement
1899                     ($1.location, build_try_statement ($1.location,
1900                                                        $2, $3), $4);
1901                 }
1902 |       TRY_TK error
1903                 {yyerror ("'{' expected"); DRECOVER (try_statement);}
1904 ;
1905
1906 catches:
1907         catch_clause
1908 |       catches catch_clause
1909                 {
1910                   TREE_CHAIN ($2) = $1;
1911                   $$ = $2;
1912                 }
1913 ;
1914
1915 catch_clause:
1916         catch_clause_parameter block
1917                 {
1918                   java_method_add_stmt (current_function_decl, $2);
1919                   exit_block ();
1920                   $$ = $1;
1921                 }
1922 ;
1923
1924 catch_clause_parameter:
1925         CATCH_TK OP_TK formal_parameter CP_TK
1926                 {
1927                   /* We add a block to define a scope for
1928                      formal_parameter (CCBP). The formal parameter is
1929                      declared initialized by the appropriate function
1930                      call */
1931                   tree ccpb;
1932                   tree init;
1933                   if ($3)
1934                     {
1935                       ccpb = enter_block ();
1936                       init = build_assignment
1937                         (ASSIGN_TK, $2.location, TREE_PURPOSE ($3),
1938                          build0 (JAVA_EXC_OBJ_EXPR, ptr_type_node));
1939                       declare_local_variables (0, TREE_VALUE ($3),
1940                                                build_tree_list
1941                                                (TREE_PURPOSE ($3), init));
1942                       $$ = build1 (JAVA_CATCH_EXPR, NULL_TREE, ccpb);
1943                       SET_EXPR_LOCATION_FROM_TOKEN ($$, $1);
1944                     }
1945                   else
1946                     {
1947                       $$ = error_mark_node;
1948                     }
1949                 }
1950 |       CATCH_TK error
1951                 {yyerror ("'(' expected"); RECOVER; $$ = NULL_TREE;}
1952 |       CATCH_TK OP_TK error
1953                 {
1954                   yyerror ("Missing term or ')' expected");
1955                   RECOVER; $$ = NULL_TREE;
1956                 }
1957 |       CATCH_TK OP_TK error CP_TK /* That's for () */
1958                 {yyerror ("Missing term"); RECOVER; $$ = NULL_TREE;}
1959 ;
1960
1961 finally:
1962         FINALLY_TK block
1963                 { $$ = $2; }
1964 |       FINALLY_TK error
1965                 {yyerror ("'{' expected"); RECOVER; }
1966 ;
1967
1968 /* 19.12 Production from 15: Expressions  */
1969 primary:
1970         primary_no_new_array
1971 |       array_creation_uninitialized
1972 |       array_creation_initialized
1973 ;
1974
1975 primary_no_new_array:
1976         literal
1977 |       THIS_TK
1978                 { $$ = build_this ($1.location); }
1979 |       OP_TK expression CP_TK
1980                 {$$ = $2;}
1981 |       class_instance_creation_expression
1982 |       field_access
1983 |       method_invocation
1984 |       array_access
1985 |       type_literals
1986         /* Added, JDK1.1 inner classes. Documentation is wrong
1987            referring to a 'ClassName' (class_name) rule that doesn't
1988            exist. Used name: instead.  */
1989 |       name DOT_TK THIS_TK
1990                 {
1991                   tree wfl = build_wfl_node (this_identifier_node);
1992                   $$ = make_qualified_primary ($1, wfl, EXPR_WFL_LINECOL ($1));
1993                 }
1994 |       OP_TK expression error
1995                 {yyerror ("')' expected"); RECOVER;}
1996 |       name DOT_TK error
1997                 {yyerror ("'class' or 'this' expected" ); RECOVER;}
1998 |       primitive_type DOT_TK error
1999                 {yyerror ("'class' expected" ); RECOVER;}
2000 |       VOID_TK DOT_TK error
2001                 {yyerror ("'class' expected" ); RECOVER;}
2002 ;
2003
2004 type_literals:
2005         name DOT_TK CLASS_TK
2006                 { $$ = build_incomplete_class_ref ($2.location, $1); }
2007 |       array_type DOT_TK CLASS_TK
2008                 { $$ = build_incomplete_class_ref ($2.location, $1); }
2009 |       primitive_type DOT_TK CLASS_TK
2010                 { $$ = build_incomplete_class_ref ($2.location, $1); }
2011 |       VOID_TK DOT_TK CLASS_TK
2012                 {
2013                    $$ = build_incomplete_class_ref ($2.location,
2014                                                    void_type_node);
2015                 }
2016 ;
2017
2018 class_instance_creation_expression:
2019         NEW_TK class_type OP_TK argument_list CP_TK
2020                 { $$ = build_new_invocation ($2, $4); }
2021 |       NEW_TK class_type OP_TK CP_TK
2022                 { $$ = build_new_invocation ($2, NULL_TREE); }
2023 |       anonymous_class_creation
2024         /* Added, JDK1.1 inner classes, modified to use name or
2025            primary instead of primary solely which couldn't work in
2026            all situations.  */
2027 |       something_dot_new identifier OP_TK CP_TK
2028                 {
2029                   tree ctor = build_new_invocation ($2, NULL_TREE);
2030                   $$ = make_qualified_primary ($1, ctor,
2031                                                EXPR_WFL_LINECOL ($1));
2032                 }
2033 |       something_dot_new identifier OP_TK CP_TK class_body
2034 |       something_dot_new identifier OP_TK argument_list CP_TK
2035                 {
2036                   tree ctor = build_new_invocation ($2, $4);
2037                   $$ = make_qualified_primary ($1, ctor,
2038                                                EXPR_WFL_LINECOL ($1));
2039                 }
2040 |       something_dot_new identifier OP_TK argument_list CP_TK class_body
2041 |       NEW_TK error SC_TK
2042                 {$$ = NULL_TREE; yyerror ("'(' expected"); DRECOVER(new_1);}
2043 |       NEW_TK class_type error
2044                 {$$ = NULL_TREE; yyerror ("'(' expected"); RECOVER;}
2045 |       NEW_TK class_type OP_TK error
2046                 {$$ = NULL_TREE; yyerror ("')' or term expected"); RECOVER;}
2047 |       NEW_TK class_type OP_TK argument_list error
2048                 {$$ = NULL_TREE; yyerror ("')' expected"); RECOVER;}
2049 |       something_dot_new error
2050                 {
2051                   $$ = NULL_TREE;
2052                   YYERROR_NOW;
2053                   yyerror ("Identifier expected");
2054                   RECOVER;
2055                 }
2056 |       something_dot_new identifier error
2057                 {$$ = NULL_TREE; yyerror ("'(' expected"); RECOVER;}
2058 ;
2059
2060 /* Created after JDK1.1 rules originally added to
2061    class_instance_creation_expression, but modified to use
2062    'class_type' instead of 'TypeName' (type_name) which is mentioned
2063    in the documentation but doesn't exist. */
2064
2065 anonymous_class_creation:
2066         NEW_TK class_type OP_TK argument_list CP_TK
2067                 { create_anonymous_class ($2); }
2068         class_body
2069                 {
2070                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2071                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2072
2073                   end_class_declaration (1);
2074
2075                   /* Now we can craft the new expression */
2076                   $$ = build_new_invocation (id, $4);
2077
2078                   /* Note that we can't possibly be here if
2079                      `class_type' is an interface (in which case the
2080                      anonymous class extends Object and implements
2081                      `class_type', hence its constructor can't have
2082                      arguments.) */
2083
2084                   /* Otherwise, the innerclass must feature a
2085                      constructor matching `argument_list'. Anonymous
2086                      classes are a bit special: it's impossible to
2087                      define constructor for them, hence constructors
2088                      must be generated following the hints provided by
2089                      the `new' expression. Whether a super constructor
2090                      of that nature exists or not is to be verified
2091                      later on in get_constructor_super.
2092
2093                      It's during the expansion of a `new' statement
2094                      referring to an anonymous class that a ctor will
2095                      be generated for the anonymous class, with the
2096                      right arguments. */
2097
2098                 }
2099 |       NEW_TK class_type OP_TK CP_TK
2100                 { create_anonymous_class ($2); }
2101         class_body
2102                 {
2103                   tree id = build_wfl_node (DECL_NAME (GET_CPC ()));
2104                   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL ($2);
2105
2106                   end_class_declaration (1);
2107
2108                   /* Now we can craft the new expression. The
2109                      statement doesn't need to be remember so that a
2110                      constructor can be generated, since its signature
2111                      is already known. */
2112                   $$ = build_new_invocation (id, NULL_TREE);
2113                 }
2114 ;
2115
2116 something_dot_new:              /* Added, not part of the specs. */
2117         name DOT_TK NEW_TK
2118                 { $$ = $1; }
2119 |       primary DOT_TK NEW_TK
2120                 { $$ = $1; }
2121 ;
2122
2123 argument_list:
2124         expression
2125                 {
2126                   $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
2127                   ctxp->formal_parameter_number = 1;
2128                 }
2129 |       argument_list C_TK expression
2130                 {
2131                   ctxp->formal_parameter_number += 1;
2132                   $$ = tree_cons (NULL_TREE, $3, $1);
2133                 }
2134 |       argument_list C_TK error
2135                 {yyerror ("Missing term"); RECOVER;}
2136 ;
2137
2138 array_creation_uninitialized:
2139         NEW_TK primitive_type dim_exprs
2140                 { $$ = build_newarray_node ($2, $3, 0); }
2141 |       NEW_TK class_or_interface_type dim_exprs
2142                 { $$ = build_newarray_node ($2, $3, 0); }
2143 |       NEW_TK primitive_type dim_exprs dims
2144                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2145 |       NEW_TK class_or_interface_type dim_exprs dims
2146                 { $$ = build_newarray_node ($2, $3, pop_current_osb (ctxp));}
2147 |       NEW_TK error CSB_TK
2148                 {yyerror ("'[' expected"); DRECOVER ("]");}
2149 |       NEW_TK error OSB_TK
2150                 {yyerror ("']' expected"); RECOVER;}
2151 ;
2152
2153 array_creation_initialized:
2154         /* Added, JDK1.1 anonymous array. Initial documentation rule
2155            modified */
2156         NEW_TK class_or_interface_type dims array_initializer
2157                 {
2158                   char *sig;
2159                   int osb = pop_current_osb (ctxp);
2160                   while (osb--)
2161                     obstack_grow (&temporary_obstack, "[]", 2);
2162                   obstack_1grow (&temporary_obstack, '\0');
2163                   sig = obstack_finish (&temporary_obstack);
2164                   $$ = build3 (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2165                                $2, get_identifier (sig), $4);
2166                 }
2167 |       NEW_TK primitive_type dims array_initializer
2168                 {
2169                   int osb = pop_current_osb (ctxp);
2170                   tree type = $2;
2171                   while (osb--)
2172                     type = build_java_array_type (type, -1);
2173                   $$ = build3 (NEW_ANONYMOUS_ARRAY_EXPR, NULL_TREE,
2174                                build_pointer_type (type), NULL_TREE, $4);
2175                 }
2176 |       NEW_TK error CSB_TK
2177                 {yyerror ("'[' expected"); DRECOVER ("]");}
2178 |       NEW_TK error OSB_TK
2179                 {yyerror ("']' expected"); RECOVER;}
2180 ;
2181
2182 dim_exprs:
2183         dim_expr
2184                 { $$ = build_tree_list (NULL_TREE, $1); }
2185 |       dim_exprs dim_expr
2186                 { $$ = tree_cons (NULL_TREE, $2, $$); }
2187 ;
2188
2189 dim_expr:
2190         OSB_TK expression CSB_TK
2191                 {
2192                   if (JNUMERIC_TYPE_P (TREE_TYPE ($2)))
2193                     {
2194                       $2 = build_wfl_node ($2);
2195                       TREE_TYPE ($2) = NULL_TREE;
2196                     }
2197                   EXPR_WFL_LINECOL ($2) = $1.location;
2198                   $$ = $2;
2199                 }
2200 |       OSB_TK expression error
2201                 {yyerror ("']' expected"); RECOVER;}
2202 |       OSB_TK error
2203                 {
2204                   yyerror ("Missing term");
2205                   yyerror ("']' expected");
2206                   RECOVER;
2207                 }
2208 ;
2209
2210 dims:
2211         OSB_TK CSB_TK
2212                 {
2213                   int allocate = 0;
2214                   /* If not initialized, allocate memory for the osb
2215                      numbers stack */
2216                   if (!ctxp->osb_limit)
2217                     {
2218                       allocate = ctxp->osb_limit = 32;
2219                       ctxp->osb_depth = -1;
2220                     }
2221                   /* If capacity overflown, reallocate a bigger chunk */
2222                   else if (ctxp->osb_depth+1 == ctxp->osb_limit)
2223                     allocate = ctxp->osb_limit << 1;
2224
2225                   if (allocate)
2226                     {
2227                       allocate *= sizeof (int);
2228                       if (ctxp->osb_number)
2229                         ctxp->osb_number = xrealloc (ctxp->osb_number,
2230                                                      allocate);
2231                       else
2232                         ctxp->osb_number = xmalloc (allocate);
2233                     }
2234                   ctxp->osb_depth++;
2235                   CURRENT_OSB (ctxp) = 1;
2236                 }
2237 |       dims OSB_TK CSB_TK
2238                 { CURRENT_OSB (ctxp)++; }
2239 |       dims OSB_TK error
2240                 { yyerror ("']' expected"); RECOVER;}
2241 ;
2242
2243 field_access:
2244         primary DOT_TK identifier
2245                 { $$ = make_qualified_primary ($1, $3, $2.location); }
2246                 /*  FIXME - REWRITE TO:
2247                 { $$ = build_binop (COMPONENT_REF, $2.location, $1, $3); } */
2248 |       SUPER_TK DOT_TK identifier
2249                 {
2250                   tree super_wfl = build_wfl_node (super_identifier_node);
2251                   SET_EXPR_LOCATION_FROM_TOKEN (super_wfl, $1);
2252                   $$ = make_qualified_name (super_wfl, $3, $2.location);
2253                 }
2254 |       SUPER_TK error
2255                 {yyerror ("Field expected"); DRECOVER (super_field_acces);}
2256 ;
2257
2258 method_invocation:
2259         name OP_TK CP_TK
2260                 { $$ = build_method_invocation ($1, NULL_TREE); }
2261 |       name OP_TK argument_list CP_TK
2262                 { $$ = build_method_invocation ($1, $3); }
2263 |       primary DOT_TK identifier OP_TK CP_TK
2264                 {
2265                   if (TREE_CODE ($1) == THIS_EXPR)
2266                     $$ = build_this_super_qualified_invocation
2267                       (1, $3, NULL_TREE, 0, $2.location);
2268                   else
2269                     {
2270                       tree invok = build_method_invocation ($3, NULL_TREE);
2271                       $$ = make_qualified_primary ($1, invok, $2.location);
2272                     }
2273                 }
2274 |       primary DOT_TK identifier OP_TK argument_list CP_TK
2275                 {
2276                   if (TREE_CODE ($1) == THIS_EXPR)
2277                     $$ = build_this_super_qualified_invocation
2278                       (1, $3, $5, 0, $2.location);
2279                   else
2280                     {
2281                       tree invok = build_method_invocation ($3, $5);
2282                       $$ = make_qualified_primary ($1, invok, $2.location);
2283                     }
2284                 }
2285 |       SUPER_TK DOT_TK identifier OP_TK CP_TK
2286                 {
2287                   $$ = build_this_super_qualified_invocation
2288                     (0, $3, NULL_TREE, $1.location, $2.location);
2289                 }
2290 |       SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
2291                 {
2292                   $$ = build_this_super_qualified_invocation
2293                     (0, $3, $5, $1.location, $2.location);
2294                 }
2295         /* Screws up thing. I let it here until I'm convinced it can
2296            be removed. FIXME
2297 |       primary DOT_TK error
2298                 {yyerror ("'(' expected"); DRECOVER(bad);} */
2299 |       SUPER_TK DOT_TK error CP_TK
2300                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2301 |       SUPER_TK DOT_TK error DOT_TK
2302                 { yyerror ("'(' expected"); DRECOVER (method_invocation); }
2303 ;
2304
2305 array_access:
2306         name OSB_TK expression CSB_TK
2307                 { $$ = build_array_ref ($2.location, $1, $3); }
2308 |       primary_no_new_array OSB_TK expression CSB_TK
2309                 { $$ = build_array_ref ($2.location, $1, $3); }
2310 |       array_creation_initialized OSB_TK expression CSB_TK
2311                 { $$ = build_array_ref ($2.location, $1, $3); }
2312 |       name OSB_TK error
2313                 {
2314                   yyerror ("Missing term and ']' expected");
2315                   DRECOVER(array_access);
2316                 }
2317 |       name OSB_TK expression error
2318                 {
2319                   yyerror ("']' expected");
2320                   DRECOVER(array_access);
2321                 }
2322 |       primary_no_new_array OSB_TK error
2323                 {
2324                   yyerror ("Missing term and ']' expected");
2325                   DRECOVER(array_access);
2326                 }
2327 |       primary_no_new_array OSB_TK expression error
2328                 {
2329                   yyerror ("']' expected");
2330                   DRECOVER(array_access);
2331                 }
2332 |       array_creation_initialized OSB_TK error
2333                 {
2334                   yyerror ("Missing term and ']' expected");
2335                   DRECOVER(array_access);
2336                 }
2337 |       array_creation_initialized OSB_TK expression error
2338                 {
2339                   yyerror ("']' expected");
2340                   DRECOVER(array_access);
2341                 }
2342 ;
2343
2344 postfix_expression:
2345         primary
2346 |       name
2347 |       post_increment_expression
2348 |       post_decrement_expression
2349 ;
2350
2351 post_increment_expression:
2352         postfix_expression INCR_TK
2353                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2354 ;
2355
2356 post_decrement_expression:
2357         postfix_expression DECR_TK
2358                 { $$ = build_incdec ($2.token, $2.location, $1, 1); }
2359 ;
2360
2361 trap_overflow_corner_case:
2362         pre_increment_expression
2363 |       pre_decrement_expression
2364 |       PLUS_TK unary_expression
2365                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2366 |       unary_expression_not_plus_minus
2367 |       PLUS_TK error
2368                 {yyerror ("Missing term"); RECOVER}
2369 ;
2370
2371 unary_expression:
2372         trap_overflow_corner_case
2373                 {
2374                   if ($1)
2375                     error_if_numeric_overflow ($1);
2376                   $$ = $1;
2377                 }
2378 |       MINUS_TK trap_overflow_corner_case
2379                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2380 |       MINUS_TK error
2381                 {yyerror ("Missing term"); RECOVER}
2382 ;
2383
2384 pre_increment_expression:
2385         INCR_TK unary_expression
2386                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2387 |       INCR_TK error
2388                 {yyerror ("Missing term"); RECOVER}
2389 ;
2390
2391 pre_decrement_expression:
2392         DECR_TK unary_expression
2393                 {$$ = build_incdec ($1.token, $1.location, $2, 0); }
2394 |       DECR_TK error
2395                 {yyerror ("Missing term"); RECOVER}
2396 ;
2397
2398 unary_expression_not_plus_minus:
2399         postfix_expression
2400 |       NOT_TK unary_expression
2401                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2402 |       NEG_TK unary_expression
2403                 {$$ = build_unaryop ($1.token, $1.location, $2); }
2404 |       cast_expression
2405 |       NOT_TK error
2406                 {yyerror ("Missing term"); RECOVER}
2407 |       NEG_TK error
2408                 {yyerror ("Missing term"); RECOVER}
2409 ;
2410
2411 cast_expression:                /* Error handling here is potentially weak */
2412         OP_TK primitive_type dims CP_TK unary_expression
2413                 {
2414                   tree type = $2;
2415                   int osb = pop_current_osb (ctxp);
2416                   while (osb--)
2417                     type = build_java_array_type (type, -1);
2418                   $$ = build_cast ($1.location, type, $5);
2419                 }
2420 |       OP_TK primitive_type CP_TK unary_expression
2421                 { $$ = build_cast ($1.location, $2, $4); }
2422 |       OP_TK expression CP_TK unary_expression_not_plus_minus
2423                 { $$ = build_cast ($1.location, $2, $4); }
2424 |       OP_TK name dims CP_TK unary_expression_not_plus_minus
2425                 {
2426                   const char *ptr;
2427                   int osb = pop_current_osb (ctxp);
2428                   obstack_grow (&temporary_obstack,
2429                                 IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
2430                                 IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
2431                   while (osb--)
2432                     obstack_grow (&temporary_obstack, "[]", 2);
2433                   obstack_1grow (&temporary_obstack, '\0');
2434                   ptr = obstack_finish (&temporary_obstack);
2435                   EXPR_WFL_NODE ($2) = get_identifier (ptr);
2436                   $$ = build_cast ($1.location, $2, $5);
2437                 }
2438 |       OP_TK primitive_type OSB_TK error
2439                 {yyerror ("']' expected, invalid type expression");}
2440 |       OP_TK error
2441                 {
2442                   YYNOT_TWICE yyerror ("Invalid type expression"); RECOVER;
2443                   RECOVER;
2444                 }
2445 |       OP_TK primitive_type dims CP_TK error
2446                 {yyerror ("Missing term"); RECOVER;}
2447 |       OP_TK primitive_type CP_TK error
2448                 {yyerror ("Missing term"); RECOVER;}
2449 |       OP_TK name dims CP_TK error
2450                 {yyerror ("Missing term"); RECOVER;}
2451 ;
2452
2453 multiplicative_expression:
2454         unary_expression
2455 |       multiplicative_expression MULT_TK unary_expression
2456                 {
2457                   $$ = build_binop (BINOP_LOOKUP ($2.token),
2458                                     $2.location, $1, $3);
2459                 }
2460 |       multiplicative_expression DIV_TK unary_expression
2461                 {
2462                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2463                                     $1, $3);
2464                 }
2465 |       multiplicative_expression REM_TK unary_expression
2466                 {
2467                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2468                                     $1, $3);
2469                 }
2470 |       multiplicative_expression MULT_TK error
2471                 {yyerror ("Missing term"); RECOVER;}
2472 |       multiplicative_expression DIV_TK error
2473                 {yyerror ("Missing term"); RECOVER;}
2474 |       multiplicative_expression REM_TK error
2475                 {yyerror ("Missing term"); RECOVER;}
2476 ;
2477
2478 additive_expression:
2479         multiplicative_expression
2480 |       additive_expression PLUS_TK multiplicative_expression
2481                 {
2482                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2483                                     $1, $3);
2484                 }
2485 |       additive_expression MINUS_TK multiplicative_expression
2486                 {
2487                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2488                                     $1, $3);
2489                 }
2490 |       additive_expression PLUS_TK error
2491                 {yyerror ("Missing term"); RECOVER;}
2492 |       additive_expression MINUS_TK error
2493                 {yyerror ("Missing term"); RECOVER;}
2494 ;
2495
2496 shift_expression:
2497         additive_expression
2498 |       shift_expression LS_TK additive_expression
2499                 {
2500                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2501                                     $1, $3);
2502                 }
2503 |       shift_expression SRS_TK additive_expression
2504                 {
2505                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2506                                     $1, $3);
2507                 }
2508 |       shift_expression ZRS_TK additive_expression
2509                 {
2510                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2511                                     $1, $3);
2512                 }
2513 |       shift_expression LS_TK error
2514                 {yyerror ("Missing term"); RECOVER;}
2515 |       shift_expression SRS_TK error
2516                 {yyerror ("Missing term"); RECOVER;}
2517 |       shift_expression ZRS_TK error
2518                 {yyerror ("Missing term"); RECOVER;}
2519 ;
2520
2521 relational_expression:
2522         shift_expression
2523 |       relational_expression LT_TK shift_expression
2524                 {
2525                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2526                                     $1, $3);
2527                 }
2528 |       relational_expression GT_TK shift_expression
2529                 {
2530                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2531                                     $1, $3);
2532                 }
2533 |       relational_expression LTE_TK shift_expression
2534                 {
2535                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2536                                     $1, $3);
2537                 }
2538 |       relational_expression GTE_TK shift_expression
2539                 {
2540                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2541                                     $1, $3);
2542                 }
2543 |       relational_expression INSTANCEOF_TK reference_type
2544                 { $$ = build_binop (INSTANCEOF_EXPR, $2.location, $1, $3); }
2545 |       relational_expression LT_TK error
2546                 {yyerror ("Missing term"); RECOVER;}
2547 |       relational_expression GT_TK error
2548                 {yyerror ("Missing term"); RECOVER;}
2549 |       relational_expression LTE_TK error
2550                 {yyerror ("Missing term"); RECOVER;}
2551 |       relational_expression GTE_TK error
2552                 {yyerror ("Missing term"); RECOVER;}
2553 |       relational_expression INSTANCEOF_TK error
2554                 {yyerror ("Invalid reference type"); RECOVER;}
2555 ;
2556
2557 equality_expression:
2558         relational_expression
2559 |       equality_expression EQ_TK relational_expression
2560                 {
2561                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2562                                     $1, $3);
2563                 }
2564 |       equality_expression NEQ_TK relational_expression
2565                 {
2566                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2567                                     $1, $3);
2568                 }
2569 |       equality_expression EQ_TK error
2570                 {yyerror ("Missing term"); RECOVER;}
2571 |       equality_expression NEQ_TK error
2572                 {yyerror ("Missing term"); RECOVER;}
2573 ;
2574
2575 and_expression:
2576         equality_expression
2577 |       and_expression AND_TK equality_expression
2578                 {
2579                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2580                                     $1, $3);
2581                 }
2582 |       and_expression AND_TK error
2583                 {yyerror ("Missing term"); RECOVER;}
2584 ;
2585
2586 exclusive_or_expression:
2587         and_expression
2588 |       exclusive_or_expression XOR_TK and_expression
2589                 {
2590                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2591                                     $1, $3);
2592                 }
2593 |       exclusive_or_expression XOR_TK error
2594                 {yyerror ("Missing term"); RECOVER;}
2595 ;
2596
2597 inclusive_or_expression:
2598         exclusive_or_expression
2599 |       inclusive_or_expression OR_TK exclusive_or_expression
2600                 {
2601                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2602                                     $1, $3);
2603                 }
2604 |       inclusive_or_expression OR_TK error
2605                 {yyerror ("Missing term"); RECOVER;}
2606 ;
2607
2608 conditional_and_expression:
2609         inclusive_or_expression
2610 |       conditional_and_expression BOOL_AND_TK inclusive_or_expression
2611                 {
2612                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2613                                     $1, $3);
2614                 }
2615 |       conditional_and_expression BOOL_AND_TK error
2616                 {yyerror ("Missing term"); RECOVER;}
2617 ;
2618
2619 conditional_or_expression:
2620         conditional_and_expression
2621 |       conditional_or_expression BOOL_OR_TK conditional_and_expression
2622                 {
2623                   $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
2624                                     $1, $3);
2625                 }
2626 |       conditional_or_expression BOOL_OR_TK error
2627                 {yyerror ("Missing term"); RECOVER;}
2628 ;
2629
2630 conditional_expression:         /* Error handling here is weak */
2631         conditional_or_expression
2632 |       conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
2633                 {
2634                   $$ = build3 (CONDITIONAL_EXPR, NULL_TREE, $1, $3, $5);
2635                   SET_EXPR_LOCATION_FROM_TOKEN ($$, $2);
2636                 }
2637 |       conditional_or_expression REL_QM_TK REL_CL_TK error
2638                 {
2639                   YYERROR_NOW;
2640                   yyerror ("Missing term");
2641                   DRECOVER (1);
2642                 }
2643 |       conditional_or_expression REL_QM_TK error
2644                 {yyerror ("Missing term"); DRECOVER (2);}
2645 |       conditional_or_expression REL_QM_TK expression REL_CL_TK error
2646                 {yyerror ("Missing term"); DRECOVER (3);}
2647 ;
2648
2649 assignment_expression:
2650         conditional_expression
2651 |       assignment
2652 ;
2653
2654 assignment:
2655         left_hand_side assignment_operator assignment_expression
2656                 { $$ = build_assignment ($2.token, $2.location, $1, $3); }
2657 |       left_hand_side assignment_operator error
2658                 {
2659                   YYNOT_TWICE yyerror ("Missing term");
2660                   DRECOVER (assign);
2661                 }
2662 ;
2663
2664 left_hand_side:
2665         name
2666 |       field_access
2667 |       array_access
2668 ;
2669
2670 assignment_operator:
2671         ASSIGN_ANY_TK
2672 |       ASSIGN_TK
2673 ;
2674
2675 expression:
2676         assignment_expression
2677 ;
2678
2679 constant_expression:
2680         expression
2681 ;
2682
2683 %%
2684
2685 /* Helper function to retrieve an OSB count. Should be used when the
2686    `dims:' rule is being used.  */
2687
2688 static int
2689 pop_current_osb (struct parser_ctxt *ctxp)
2690 {
2691   int to_return;
2692
2693   if (ctxp->osb_depth < 0)
2694     abort ();
2695
2696   to_return = CURRENT_OSB (ctxp);
2697   ctxp->osb_depth--;
2698
2699   return to_return;
2700 }
2701
2702 \f
2703
2704 /* This section of the code deal with save/restoring parser contexts.
2705    Add mode documentation here. FIXME */
2706
2707 /* Helper function. Create a new parser context. With
2708    COPY_FROM_PREVIOUS set to a nonzero value, content of the previous
2709    context is copied, otherwise, the new context is zeroed. The newly
2710    created context becomes the current one.  */
2711
2712 static void
2713 create_new_parser_context (int copy_from_previous)
2714 {
2715   struct parser_ctxt *new;
2716
2717   new = ggc_alloc (sizeof (struct parser_ctxt));
2718   if (copy_from_previous)
2719     {
2720       memcpy (new, ctxp, sizeof (struct parser_ctxt));
2721       /* This flag, indicating the context saves global values,
2722          should only be set by java_parser_context_save_global.  */
2723       new->saved_data_ctx = 0;
2724     }
2725   else
2726     memset (new, 0, sizeof (struct parser_ctxt));
2727
2728   new->next = ctxp;
2729   ctxp = new;
2730 }
2731
2732 /* Create a new parser context and make it the current one. */
2733
2734 void
2735 java_push_parser_context (void)
2736 {
2737   create_new_parser_context (0);
2738 }
2739
2740 void
2741 java_pop_parser_context (int generate)
2742 {
2743   tree current;
2744   struct parser_ctxt *next;
2745
2746   if (!ctxp)
2747     return;
2748
2749   next = ctxp->next;
2750   if (next)
2751     {
2752       input_location = ctxp->save_location;
2753       current_class = ctxp->class_type;
2754     }
2755
2756   /* If the old and new lexers differ, then free the old one.  */
2757   if (ctxp->lexer && next && ctxp->lexer != next->lexer)
2758     java_destroy_lexer (ctxp->lexer);
2759
2760   /* Set the single import class file flag to 0 for the current list
2761      of imported things */
2762   for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2763     IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 0;
2764
2765   /* If we pushed a context to parse a class intended to be generated,
2766      we keep it so we can remember the class. What we could actually
2767      do is to just update a list of class names.  */
2768   if (generate)
2769     {
2770       if (ctxp_for_generation_last == NULL)
2771         ctxp_for_generation = ctxp;
2772       else
2773         ctxp_for_generation_last->next = ctxp;
2774       ctxp->next = NULL;
2775       ctxp_for_generation_last = ctxp;
2776     }
2777
2778   /* And restore those of the previous context */
2779   if ((ctxp = next))            /* Assignment is really meant here */
2780     for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
2781       IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_VALUE (current)) = 1;
2782 }
2783
2784 /* Create a parser context for the use of saving some global
2785    variables.  */
2786
2787 void
2788 java_parser_context_save_global (void)
2789 {
2790   if (!ctxp)
2791     {
2792       java_push_parser_context ();
2793       ctxp->saved_data_ctx = 1;
2794     }
2795
2796   /* If this context already stores data, create a new one suitable
2797      for data storage. */
2798   else if (ctxp->saved_data)
2799     {
2800       create_new_parser_context (1);
2801       ctxp->saved_data_ctx = 1;
2802     }
2803
2804   ctxp->save_location = input_location;
2805   ctxp->class_type = current_class;
2806   ctxp->function_decl = current_function_decl;
2807   ctxp->saved_data = 1;
2808 }
2809
2810 /* Restore some global variables from the previous context. Make the
2811    previous context the current one.  */
2812
2813 void
2814 java_parser_context_restore_global (void)
2815 {
2816   input_location = ctxp->save_location;
2817   current_class = ctxp->class_type;
2818   if (wfl_operator)
2819 #ifdef USE_MAPPED_LOCATION
2820     SET_EXPR_LOCATION (wfl_operator, ctxp->save_location);
2821 #else
2822     EXPR_WFL_FILENAME_NODE (wfl_operator) = get_identifier (input_filename);
2823 #endif
2824   current_function_decl = ctxp->function_decl;
2825   ctxp->saved_data = 0;
2826   if (ctxp->saved_data_ctx)
2827     java_pop_parser_context (0);
2828 }
2829
2830 /* Suspend vital data for the current class/function being parsed so
2831    that an other class can be parsed. Used to let local/anonymous
2832    classes be parsed.  */
2833
2834 static void
2835 java_parser_context_suspend (void)
2836 {
2837   /* This makes debugging through java_debug_context easier */
2838   static const char *const name = "<inner buffer context>";
2839
2840   /* Duplicate the previous context, use it to save the globals we're
2841      interested in */
2842   create_new_parser_context (1);
2843   ctxp->function_decl = current_function_decl;
2844   ctxp->class_type = current_class;
2845
2846   /* Then create a new context which inherits all data from the
2847      previous one. This will be the new current context  */
2848   create_new_parser_context (1);
2849
2850   /* Help debugging */
2851   ctxp->next->filename = name;
2852 }
2853
2854 /* Resume vital data for the current class/function being parsed so
2855    that an other class can be parsed. Used to let local/anonymous
2856    classes be parsed.  The trick is the data storing file position
2857    informations must be restored to their current value, so parsing
2858    can resume as if no context was ever saved. */
2859
2860 static void
2861 java_parser_context_resume (void)
2862 {
2863   struct parser_ctxt *old = ctxp;             /* This one is to be discarded */
2864   struct parser_ctxt *saver = old->next;      /* This one contain saved info */
2865   struct parser_ctxt *restored = saver->next; /* This one is the old current */
2866
2867   /* We need to inherit the list of classes to complete/generate */
2868   restored->classd_list = old->classd_list;
2869   restored->class_list = old->class_list;
2870
2871   /* Restore the current class and function from the saver */
2872   current_class = saver->class_type;
2873   current_function_decl = saver->function_decl;
2874
2875   /* Retrieve the restored context */
2876   ctxp = restored;
2877
2878   /* Re-installed the data for the parsing to carry on */
2879   memcpy (&ctxp->marker_begining, &old->marker_begining,
2880           (size_t)(&ctxp->marker_end - &ctxp->marker_begining));
2881 }
2882
2883 /* Add a new anchor node to which all statement(s) initializing static
2884    and non static initialized upon declaration field(s) will be
2885    linked.  */
2886
2887 static void
2888 java_parser_context_push_initialized_field (void)
2889 {
2890   tree node;
2891
2892   node = build_tree_list (NULL_TREE, NULL_TREE);
2893   TREE_CHAIN (node) = CPC_STATIC_INITIALIZER_LIST (ctxp);
2894   CPC_STATIC_INITIALIZER_LIST (ctxp) = node;
2895
2896   node = build_tree_list (NULL_TREE, NULL_TREE);
2897   TREE_CHAIN (node) = CPC_INITIALIZER_LIST (ctxp);
2898   CPC_INITIALIZER_LIST (ctxp) = node;
2899
2900   node = build_tree_list (NULL_TREE, NULL_TREE);
2901   TREE_CHAIN (node) = CPC_INSTANCE_INITIALIZER_LIST (ctxp);
2902   CPC_INSTANCE_INITIALIZER_LIST (ctxp) = node;
2903 }
2904
2905 /* Pop the lists of initialized field. If this lists aren't empty,
2906    remember them so we can use it to create and populate the finit$
2907    or <clinit> functions. */
2908
2909 static void
2910 java_parser_context_pop_initialized_field (void)
2911 {
2912   tree stmts;
2913   tree class_type = TREE_TYPE (GET_CPC ());
2914
2915   if (CPC_INITIALIZER_LIST (ctxp))
2916     {
2917       stmts = CPC_INITIALIZER_STMT (ctxp);
2918       CPC_INITIALIZER_LIST (ctxp) = TREE_CHAIN (CPC_INITIALIZER_LIST (ctxp));
2919       if (stmts && !java_error_count)
2920         TYPE_FINIT_STMT_LIST (class_type) = reorder_static_initialized (stmts);
2921     }
2922
2923   if (CPC_STATIC_INITIALIZER_LIST (ctxp))
2924     {
2925       stmts = CPC_STATIC_INITIALIZER_STMT (ctxp);
2926       CPC_STATIC_INITIALIZER_LIST (ctxp) =
2927         TREE_CHAIN (CPC_STATIC_INITIALIZER_LIST (ctxp));
2928       /* Keep initialization in order to enforce 8.5 */
2929       if (stmts && !java_error_count)
2930         TYPE_CLINIT_STMT_LIST (class_type) = nreverse (stmts);
2931     }
2932
2933   /* JDK 1.1 instance initializers */
2934   if (CPC_INSTANCE_INITIALIZER_LIST (ctxp))
2935     {
2936       stmts = CPC_INSTANCE_INITIALIZER_STMT (ctxp);
2937       CPC_INSTANCE_INITIALIZER_LIST (ctxp) =
2938         TREE_CHAIN (CPC_INSTANCE_INITIALIZER_LIST (ctxp));
2939       if (stmts && !java_error_count)
2940         TYPE_II_STMT_LIST (class_type) = nreverse (stmts);
2941     }
2942 }
2943
2944 static tree
2945 reorder_static_initialized (tree list)
2946 {
2947   /* We have to keep things in order. The alias initializer have to
2948      come first, then the initialized regular field, in reverse to
2949      keep them in lexical order. */
2950   tree marker, previous = NULL_TREE;
2951   for (marker = list; marker; previous = marker, marker = TREE_CHAIN (marker))
2952     if (TREE_CODE (marker) == TREE_LIST
2953         && !TREE_VALUE (marker) && !TREE_PURPOSE (marker))
2954       break;
2955
2956   /* No static initialized, the list is fine as is */
2957   if (!previous)
2958     list = TREE_CHAIN (marker);
2959
2960   /* No marker? reverse the whole list */
2961   else if (!marker)
2962     list = nreverse (list);
2963
2964   /* Otherwise, reverse what's after the marker and the new reordered
2965      sublist will replace the marker. */
2966   else
2967     {
2968       TREE_CHAIN (previous) = NULL_TREE;
2969       list = nreverse (list);
2970       list = chainon (TREE_CHAIN (marker), list);
2971     }
2972   return list;
2973 }
2974
2975 /* Helper functions to dump the parser context stack.  */
2976
2977 #define TAB_CONTEXT(C) \
2978   {int i; for (i = 0; i < (C); i++) fputc (' ', stderr);}
2979
2980 static void
2981 java_debug_context_do (int tab)
2982 {
2983   struct parser_ctxt *copy = ctxp;
2984   while (copy)
2985     {
2986       TAB_CONTEXT (tab);
2987       fprintf (stderr, "ctxt: 0x%0lX\n", (unsigned long)copy);
2988       TAB_CONTEXT (tab);
2989       fprintf (stderr, "filename: %s\n", copy->filename);
2990       TAB_CONTEXT (tab);
2991       fprintf (stderr, "package: %s\n",
2992                (copy->package ?
2993                 IDENTIFIER_POINTER (copy->package) : "<none>"));
2994       TAB_CONTEXT (tab);
2995       fprintf (stderr, "context for saving: %d\n", copy->saved_data_ctx);
2996       TAB_CONTEXT (tab);
2997       fprintf (stderr, "saved data: %d\n", copy->saved_data);
2998       copy = copy->next;
2999       tab += 2;
3000     }
3001 }
3002
3003 /* Dump the stacked up parser contexts. Intended to be called from a
3004    debugger.  */
3005
3006 void
3007 java_debug_context (void)
3008 {
3009   java_debug_context_do (0);
3010 }
3011
3012 \f
3013
3014 /* Flag for the error report routine to issue the error the first time
3015    it's called (overriding the default behavior which is to drop the
3016    first invocation and honor the second one, taking advantage of a
3017    richer context.  */
3018 static int force_error = 0;
3019
3020 /* Reporting an constructor invocation error.  */
3021 static void
3022 parse_ctor_invocation_error (void)
3023 {
3024   if (DECL_CONSTRUCTOR_P (current_function_decl))
3025     yyerror ("Constructor invocation must be first thing in a constructor");
3026   else
3027     yyerror ("Only constructors can invoke constructors");
3028 }
3029
3030 /* Reporting JDK1.1 features not implemented.  */
3031
3032 static tree
3033 parse_jdk1_1_error (const char *msg)
3034 {
3035   sorry (": %qs JDK1.1(TM) feature", msg);
3036   java_error_count++;
3037   return build_java_empty_stmt ();
3038 }
3039
3040 static int do_warning = 0;
3041
3042 void
3043 yyerror (const char *msgid)
3044 {
3045 #ifdef USE_MAPPED_LOCATION
3046   static source_location elc;
3047   expanded_location xloc = expand_location (input_location);
3048   int current_line = xloc.line;
3049 #else
3050   static java_lc elc;
3051   int save_lineno;
3052   int current_line = input_line;
3053 #endif
3054   static int prev_lineno;
3055   static const char *prev_msg;
3056
3057   char *remainder, *code_from_source;
3058
3059   if (!force_error && prev_lineno == current_line)
3060     return;
3061 #ifndef USE_MAPPED_LOCATION
3062   current_line = ctxp->lexer->token_start.line;
3063 #endif
3064
3065   /* Save current error location but report latter, when the context is
3066      richer.  */
3067   if (ctxp->java_error_flag == 0)
3068     {
3069       ctxp->java_error_flag = 1;
3070 #ifdef USE_MAPPED_LOCATION
3071       elc = input_location;
3072 #else
3073       elc = ctxp->lexer->token_start;
3074 #endif
3075       /* Do something to use the previous line if we're reaching the
3076          end of the file... */
3077 #ifdef VERBOSE_SKELETON
3078       printf ("* Error detected (%s)\n", (msgid ? msgid : "(null)"));
3079 #endif
3080       return;
3081     }
3082
3083   /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
3084   if (!force_error && msgid == prev_msg && prev_lineno == current_line)
3085     return;
3086
3087   ctxp->java_error_flag = 0;
3088   if (do_warning)
3089     java_warning_count++;
3090   else
3091     java_error_count++;
3092
3093 #if 0 /* FIXME */
3094   if (elc.col == 0 && msgid && msgid[1] == ';')
3095     elc = ctxp->prev_line_end;
3096 #endif
3097
3098   prev_msg = msgid;
3099
3100 #ifdef USE_MAPPED_LOCATION
3101   prev_lineno = current_line;
3102   code_from_source = java_get_line_col (xloc.file, current_line, xloc.column);
3103 #else
3104   save_lineno = input_line;
3105   prev_lineno = input_line = current_line;
3106   code_from_source = java_get_line_col (input_filename, current_line,
3107                                         ctxp->lexer->token_start.col);
3108 #endif
3109
3110
3111   obstack_grow0 (&temporary_obstack,
3112                  code_from_source, strlen (code_from_source));
3113   remainder = obstack_finish (&temporary_obstack);
3114   if (do_warning)
3115     warning (0, "%s.\n%s", msgid, remainder);
3116   else
3117     error ("%s.\n%s", msgid, remainder);
3118
3119   /* This allow us to cheaply avoid an extra 'Invalid expression
3120      statement' error report when errors have been already reported on
3121      the same line. This occurs when we report an error but don't have
3122      a synchronization point other than ';', which
3123      expression_statement is the only one to take care of.  */
3124 #ifndef USE_MAPPED_LOCATION
3125   input_line = save_lineno;
3126 #endif
3127   ctxp->prevent_ese = input_line;
3128 }
3129
3130 static void
3131 issue_warning_error_from_context (
3132 #ifdef USE_MAPPED_LOCATION
3133                                   source_location cl,
3134 #else
3135                                   tree cl,
3136 #endif
3137                                   const char *gmsgid, va_list *ap)
3138 {
3139 #ifdef USE_MAPPED_LOCATION
3140   source_location saved_location = input_location;
3141   expanded_location xloc = expand_location (cl);
3142 #else
3143   java_lc save_lc = ctxp->lexer->token_start;
3144   const char *saved = ctxp->filename, *saved_input_filename;
3145 #endif
3146   char buffer [4096];
3147   text_info text;
3148
3149   text.err_no = errno;
3150   text.args_ptr = ap;
3151   text.format_spec = gmsgid;
3152   pp_format (global_dc->printer, &text);
3153   pp_output_formatted_text (global_dc->printer);
3154   strncpy (buffer, pp_formatted_text (global_dc->printer), sizeof (buffer) - 1);
3155   buffer[sizeof (buffer) - 1] = '\0';
3156   pp_clear_output_area (global_dc->printer);
3157
3158   force_error = 1;
3159
3160 #ifdef USE_MAPPED_LOCATION
3161   if (xloc.file != NULL)
3162     {
3163       ctxp->filename = xloc.file;
3164       input_location = cl;
3165     }
3166 #else
3167   ctxp->lexer->token_start.line = EXPR_WFL_LINENO (cl);
3168   ctxp->lexer->token_start.col  = (EXPR_WFL_COLNO (cl) == 0xfff ? -1
3169                                    : EXPR_WFL_COLNO (cl) == 0xffe ? -2
3170                                    : EXPR_WFL_COLNO (cl));
3171
3172   /* We have a CL, that's a good reason for using it if it contains data */
3173   if (TREE_CODE (cl) == EXPR_WITH_FILE_LOCATION && EXPR_WFL_FILENAME_NODE (cl))
3174     ctxp->filename = EXPR_WFL_FILENAME (cl);
3175   saved_input_filename = input_filename;
3176   input_filename = ctxp->filename;
3177 #endif
3178   java_error (NULL);
3179   java_error (buffer);
3180 #ifdef USE_MAPPED_LOCATION
3181   input_location = saved_location;
3182 #else
3183   ctxp->filename = saved;
3184   input_filename = saved_input_filename;
3185   ctxp->lexer->token_start = save_lc;
3186 #endif
3187   force_error = 0;
3188 }
3189
3190 /* Issue an error message at a current source line CL.
3191    FUTURE/FIXME:  change cl to be a source_location. */
3192
3193 void
3194 parse_error_context (tree cl, const char *gmsgid, ...)
3195 {
3196   va_list ap;
3197   va_start (ap, gmsgid);
3198 #ifdef USE_MAPPED_LOCATION
3199   issue_warning_error_from_context (EXPR_LOCATION (cl), gmsgid, &ap);
3200 #else
3201   issue_warning_error_from_context (cl, gmsgid, &ap);
3202 #endif
3203   va_end (ap);
3204 }
3205
3206 /* Issue a warning at a current source line CL.
3207    FUTURE/FIXME:  change cl to be a source_location. */
3208
3209 static void
3210 parse_warning_context (tree cl, const char *gmsgid, ...)
3211 {
3212   va_list ap;
3213   va_start (ap, gmsgid);
3214
3215   do_warning = 1;
3216 #ifdef USE_MAPPED_LOCATION
3217   issue_warning_error_from_context (EXPR_LOCATION (cl), gmsgid, &ap);
3218 #else
3219   issue_warning_error_from_context (cl, gmsgid, &ap);
3220 #endif
3221   do_warning = 0;
3222   va_end (ap);
3223 }
3224
3225 static tree
3226 find_expr_with_wfl (tree node)
3227 {
3228   while (node)
3229     {
3230       enum tree_code_class code;
3231       tree to_return;
3232
3233       switch (TREE_CODE (node))
3234         {
3235         case BLOCK:
3236           node = BLOCK_EXPR_BODY (node);
3237           continue;
3238
3239         case COMPOUND_EXPR:
3240           to_return = find_expr_with_wfl (TREE_OPERAND (node, 0));
3241           if (to_return)
3242             return to_return;
3243           node = TREE_OPERAND (node, 1);
3244           continue;
3245
3246         case LOOP_EXPR:
3247           node = TREE_OPERAND (node, 0);
3248           continue;
3249
3250         case LABELED_BLOCK_EXPR:
3251           node = LABELED_BLOCK_BODY (node);
3252           continue;
3253
3254         default:
3255           code = TREE_CODE_CLASS (TREE_CODE (node));
3256           if (((code == tcc_unary) || (code == tcc_binary)
3257                || (code == tcc_expression))
3258               && EXPR_WFL_LINECOL (node))
3259             return node;
3260           return NULL_TREE;
3261         }
3262     }
3263   return NULL_TREE;
3264 }
3265
3266 /* Issue a missing return statement error. Uses METHOD to figure the
3267    last line of the method the error occurs in.  */
3268
3269 static void
3270 missing_return_error (tree method)
3271 {
3272 #ifdef USE_MAPPED_LOCATION
3273   SET_EXPR_LOCATION (wfl_operator, DECL_FUNCTION_LAST_LINE (method));
3274 #else
3275   EXPR_WFL_SET_LINECOL (wfl_operator, DECL_FUNCTION_LAST_LINE (method), -2);
3276 #endif
3277   parse_error_context (wfl_operator, "Missing return statement");
3278 }
3279
3280 /* Issue an unreachable statement error. From NODE, find the next
3281    statement to report appropriately.  */
3282 static void
3283 unreachable_stmt_error (tree node)
3284 {
3285   /* Browse node to find the next expression node that has a WFL. Use
3286      the location to report the error */
3287   if (TREE_CODE (node) == COMPOUND_EXPR)
3288     node = find_expr_with_wfl (TREE_OPERAND (node, 1));
3289   else
3290     node = find_expr_with_wfl (node);
3291
3292   if (node)
3293     {
3294 #ifdef USE_MAPPED_LOCATION
3295       SET_EXPR_LOCATION (wfl_operator, EXPR_LOCATION (node));
3296 #else
3297       EXPR_WFL_SET_LINECOL (wfl_operator, EXPR_WFL_LINENO (node), -2);
3298 #endif
3299       parse_error_context (wfl_operator, "Unreachable statement");
3300     }
3301   else
3302     abort ();
3303 }
3304
3305 static int
3306 not_accessible_field_error (tree wfl, tree decl)
3307 {
3308   parse_error_context
3309     (wfl, "Can't access %s field %<%s.%s%> from %qs",
3310      accessibility_string (get_access_flags_from_decl (decl)),
3311      GET_TYPE_NAME (DECL_CONTEXT (decl)),
3312      IDENTIFIER_POINTER (DECL_NAME (decl)),
3313      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
3314   return 1;
3315 }
3316
3317 int
3318 java_report_errors (void)
3319 {
3320   if (java_error_count)
3321     fprintf (stderr, "%d error%s",
3322              java_error_count, (java_error_count == 1 ? "" : "s"));
3323   if (java_warning_count)
3324     fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
3325              java_warning_count, (java_warning_count == 1 ? "" : "s"));
3326   if (java_error_count || java_warning_count)
3327     putc ('\n', stderr);
3328   return java_error_count;
3329 }
3330
3331 static char *
3332 java_accstring_lookup (int flags)
3333 {
3334   static char buffer [80];
3335 #define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
3336
3337   /* Access modifier looked-up first for easier report on forbidden
3338      access. */
3339   if (flags & ACC_PUBLIC) COPY_RETURN ("public");
3340   if (flags & ACC_PRIVATE) COPY_RETURN ("private");
3341   if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
3342   if (flags & ACC_STATIC) COPY_RETURN ("static");
3343   if (flags & ACC_FINAL) COPY_RETURN ("final");
3344   if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
3345   if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
3346   if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
3347   if (flags & ACC_NATIVE) COPY_RETURN ("native");
3348   if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
3349   if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
3350
3351   buffer [0] = '\0';
3352   return buffer;
3353 #undef COPY_RETURN
3354 }
3355
3356 /* Returns a string denoting the accessibility of a class or a member as
3357    indicated by FLAGS.  We need a separate function from
3358    java_accstring_lookup, as the latter can return spurious "static", etc.
3359    if package-private access is defined (in which case none of the
3360    relevant access control bits in FLAGS is set).  */
3361
3362 static const char *
3363 accessibility_string (int flags)
3364 {
3365   if (flags & ACC_PRIVATE) return "private";
3366   if (flags & ACC_PROTECTED) return "protected";
3367   if (flags & ACC_PUBLIC) return "public";
3368
3369   return "package-private";
3370 }
3371
3372 /* Issuing error messages upon redefinition of classes, interfaces or
3373    variables. */
3374
3375 static void
3376 classitf_redefinition_error (const char *context, tree id, tree decl, tree cl)
3377 {
3378   parse_error_context (cl, "%s %qs already defined in %s:%d",
3379                        context, IDENTIFIER_POINTER (id),
3380                        DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3381   /* Here we should point out where its redefined. It's a unicode. FIXME */
3382 }
3383
3384 static void
3385 variable_redefinition_error (tree context, tree name, tree type, int line)
3386 {
3387   const char *type_name;
3388
3389   /* Figure a proper name for type. We might haven't resolved it */
3390   if (TREE_CODE (type) == POINTER_TYPE && !TREE_TYPE (type))
3391     type_name = IDENTIFIER_POINTER (TYPE_NAME (type));
3392   else
3393     type_name = lang_printable_name (type, 0);
3394
3395   parse_error_context (context,
3396                        "Variable %qs is already defined in this method and was declared %<%s %s%> at line %d",
3397                        IDENTIFIER_POINTER (name),
3398                        type_name, IDENTIFIER_POINTER (name), line);
3399 }
3400
3401 /* If ANAME is terminated with `[]', it indicates an array. This
3402    function returns the number of `[]' found and if this number is
3403    greater than zero, it extracts the array type name and places it in
3404    the node pointed to by TRIMMED unless TRIMMED is null.  */
3405
3406 static int
3407 build_type_name_from_array_name (tree aname, tree *trimmed)
3408 {
3409   const char *name = IDENTIFIER_POINTER (aname);
3410   int len = IDENTIFIER_LENGTH (aname);
3411   int array_dims;
3412
3413   STRING_STRIP_BRACKETS (name, len, array_dims);
3414
3415   if (array_dims && trimmed)
3416     *trimmed = get_identifier_with_length (name, len);
3417
3418   return array_dims;
3419 }
3420
3421 static tree
3422 build_array_from_name (tree type, tree type_wfl, tree name, tree *ret_name)
3423 {
3424   int more_dims = 0;
3425
3426   /* Eventually get more dims */
3427   more_dims = build_type_name_from_array_name (name, &name);
3428
3429   /* If we have, then craft a new type for this variable */
3430   if (more_dims)
3431     {
3432       tree save = type;
3433
3434       /* If we have a pointer, use its type */
3435       if (TREE_CODE (type) == POINTER_TYPE)
3436         type = TREE_TYPE (type);
3437
3438       /* Building the first dimension of a primitive type uses this
3439          function */
3440       if (JPRIMITIVE_TYPE_P (type))
3441         {
3442           type = build_java_array_type (type, -1);
3443           more_dims--;
3444         }
3445       /* Otherwise, if we have a WFL for this type, use it (the type
3446          is already an array on an unresolved type, and we just keep
3447          on adding dimensions) */
3448       else if (type_wfl)
3449         {
3450           type = type_wfl;
3451           more_dims += build_type_name_from_array_name (TYPE_NAME (save),
3452                                                         NULL);
3453         }
3454
3455       /* Add all the dimensions */
3456       while (more_dims--)
3457         type = build_unresolved_array_type (type);
3458
3459       /* The type may have been incomplete in the first place */
3460       if (type_wfl)
3461         type = obtain_incomplete_type (type);
3462     }
3463
3464   if (ret_name)
3465     *ret_name = name;
3466   return type;
3467 }
3468
3469 /* Build something that the type identifier resolver will identify as
3470    being an array to an unresolved type. TYPE_WFL is a WFL on a
3471    identifier. */
3472
3473 static tree
3474 build_unresolved_array_type (tree type_or_wfl)
3475 {
3476   const char *ptr;
3477   tree wfl;
3478
3479   /* TYPE_OR_WFL might be an array on a resolved type. In this case,
3480      just create a array type */
3481   if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
3482     return build_java_array_type (type_or_wfl, -1);
3483
3484   obstack_grow (&temporary_obstack,
3485                  IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
3486                  IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
3487   obstack_grow0 (&temporary_obstack, "[]", 2);
3488   ptr = obstack_finish (&temporary_obstack);
3489 #ifdef USE_MAPPED_LOCATION
3490   wfl = build_expr_wfl (get_identifier (ptr), EXPR_LOCATION (type_or_wfl));
3491 #else
3492   wfl = build_expr_wfl (get_identifier (ptr),
3493                         EXPR_WFL_FILENAME (type_or_wfl),
3494                         EXPR_WFL_LINENO (type_or_wfl),
3495                         EXPR_WFL_COLNO (type_or_wfl));
3496 #endif
3497   /* Re-install the existing qualifications so that the type can be
3498      resolved properly. */
3499   EXPR_WFL_QUALIFICATION (wfl) = EXPR_WFL_QUALIFICATION (type_or_wfl);
3500   return wfl;
3501 }
3502
3503 static void
3504 parser_add_interface (tree class_decl, tree interface_decl, tree wfl)
3505 {
3506   if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
3507     parse_error_context (wfl, "Interface %qs repeated",
3508                          IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
3509 }
3510
3511 /* Bulk of common class/interface checks. Return 1 if an error was
3512    encountered. TAG is 0 for a class, 1 for an interface.  */
3513
3514 static int
3515 check_class_interface_creation (int is_interface, int flags, tree raw_name,
3516                                 tree qualified_name, tree decl, tree cl)
3517 {
3518   tree node;
3519   int sca = 0;                  /* Static class allowed */
3520   int icaf = 0;                 /* Inner class allowed flags */
3521   int uaaf = CLASS_MODIFIERS;   /* Usually allowed access flags */
3522
3523   if (!quiet_flag)
3524     fprintf (stderr, " %s%s %s",
3525              (CPC_INNER_P () ? "inner" : ""),
3526              (is_interface ? "interface" : "class"),
3527              IDENTIFIER_POINTER (qualified_name));
3528
3529   /* Scope of an interface/class type name:
3530        - Can't be imported by a single type import
3531        - Can't already exists in the package */
3532   if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
3533       && (node = find_name_in_single_imports (raw_name))
3534       && !CPC_INNER_P ())
3535     {
3536       parse_error_context
3537         (cl, "%s name %qs clashes with imported type %qs",
3538          (is_interface ? "Interface" : "Class"),
3539          IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
3540       return 1;
3541     }
3542   if (decl && CLASS_COMPLETE_P (decl))
3543     {
3544       classitf_redefinition_error ((is_interface ? "Interface" : "Class"),
3545                                    qualified_name, decl, cl);
3546       return 1;
3547     }
3548
3549   if (check_inner_class_redefinition (raw_name, cl))
3550     return 1;
3551
3552   /* If public, file name should match class/interface name, except
3553      when dealing with an inner class */
3554   if (!CPC_INNER_P () && (flags & ACC_PUBLIC ))
3555     {
3556       const char *fname = input_filename;
3557       const char *f;
3558
3559       for (f = fname + strlen (fname);
3560            f != fname && ! IS_DIR_SEPARATOR (*f);
3561            f--)
3562         ;
3563       if (IS_DIR_SEPARATOR (*f))
3564         f++;
3565       if (strncmp (IDENTIFIER_POINTER (raw_name),
3566                    f , IDENTIFIER_LENGTH (raw_name)) ||
3567           f [IDENTIFIER_LENGTH (raw_name)] != '.')
3568         parse_error_context
3569           (cl, "Public %s %qs must be defined in a file called %<%s.java%>",
3570                              (is_interface ? "interface" : "class"),
3571                              IDENTIFIER_POINTER (qualified_name),
3572                              IDENTIFIER_POINTER (raw_name));
3573     }
3574
3575   /* Static classes can be declared only in top level classes. Note:
3576      once static, a inner class is a top level class. */
3577   if (flags & ACC_STATIC)
3578     {
3579       /* Catch the specific error of declaring an class inner class
3580          with no toplevel enclosing class. Prevent check_modifiers from
3581          complaining a second time */
3582       if (CPC_INNER_P () && !TOPLEVEL_CLASS_DECL_P (GET_CPC()))
3583         {
3584           parse_error_context (cl, "Inner class %qs can't be static. Static classes can only occur in interfaces and top-level classes",
3585                                IDENTIFIER_POINTER (qualified_name));
3586           sca = ACC_STATIC;
3587         }
3588       /* Else, in the context of a top-level class declaration, let
3589          `check_modifiers' do its job, otherwise, give it a go */
3590       else
3591         sca = (GET_CPC_LIST () ? ACC_STATIC : 0);
3592     }
3593
3594   /* Inner classes can be declared private or protected
3595      within their enclosing classes. */
3596   if (CPC_INNER_P ())
3597     {
3598       /* A class which is local to a block can't be public, private,
3599          protected or static. But it is created final, so allow this
3600          one. */
3601       if (current_function_decl)
3602         icaf = sca = uaaf = ACC_FINAL;
3603       else
3604         {
3605           check_modifiers_consistency (flags);
3606           icaf = ACC_PROTECTED;
3607           if (! CLASS_INTERFACE (GET_CPC ()))
3608             icaf |= ACC_PRIVATE;
3609         }
3610     }
3611
3612   if (is_interface)
3613     {
3614       if (CPC_INNER_P ())
3615         uaaf = INTERFACE_INNER_MODIFIERS;
3616       else
3617         uaaf = INTERFACE_MODIFIERS;
3618
3619       check_modifiers ("Illegal modifier %qs for interface declaration",
3620                        flags, uaaf);
3621     }
3622   else
3623     check_modifiers ((current_function_decl ?
3624                       "Illegal modifier %qs for local class declaration" :
3625                       "Illegal modifier %qs for class declaration"),
3626                      flags, uaaf|sca|icaf);
3627   return 0;
3628 }
3629
3630 /* Construct a nested class name.  If the final component starts with
3631    a digit, return true.  Otherwise return false.  */
3632 static int
3633 make_nested_class_name (tree cpc_list)
3634 {
3635   tree name;
3636
3637   if (!cpc_list)
3638     return 0;
3639
3640   make_nested_class_name (TREE_CHAIN (cpc_list));
3641
3642   /* Pick the qualified name when dealing with the first upmost
3643      enclosing class */
3644   name = (TREE_CHAIN (cpc_list)
3645           ? TREE_PURPOSE (cpc_list) : DECL_NAME (TREE_VALUE (cpc_list)));
3646   obstack_grow (&temporary_obstack,
3647                 IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name));
3648   obstack_1grow (&temporary_obstack, '$');
3649
3650   return ISDIGIT (IDENTIFIER_POINTER (name)[0]);
3651 }
3652
3653 /* Can't redefine a class already defined in an earlier scope. */
3654
3655 static int
3656 check_inner_class_redefinition (tree raw_name, tree cl)
3657 {
3658   tree scope_list;
3659
3660   for (scope_list = GET_CPC_LIST (); scope_list;
3661        scope_list = GET_NEXT_ENCLOSING_CPC (scope_list))
3662     if (raw_name == GET_CPC_UN_NODE (scope_list))
3663       {
3664         parse_error_context
3665           (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",
3666            IDENTIFIER_POINTER (raw_name));
3667         return 1;
3668       }
3669   return 0;
3670 }
3671
3672 /* Tries to find a decl for CLASS_TYPE within ENCLOSING.  May return an
3673    invisible/non-accessible matching decl when an accessible one could not be
3674    found, in order to give a better error message when accessibility is
3675    checked later.  */
3676
3677 static tree
3678 resolve_inner_class (tree context, tree cl, tree enclosing, tree class_type)
3679 {
3680   tree local_super = NULL_TREE;
3681   tree candidate = NULL_TREE;
3682
3683   /* This hash table is used to register the classes we're going
3684      through when searching the current class as an inner class, in
3685      order to detect circular references.  */
3686   htab_t circularity_hash = htab_create (20, htab_hash_pointer, htab_eq_pointer,
3687                                          NULL);
3688
3689   while (enclosing)
3690     {
3691       tree decl;
3692
3693       *htab_find_slot (circularity_hash, enclosing, INSERT) = enclosing;
3694
3695       if ((decl = find_as_inner_class (enclosing, class_type, cl)))
3696         {
3697           if (inner_class_accessible (decl, context))
3698             {
3699               candidate = decl;
3700               break;
3701             }
3702           else
3703             if (candidate == NULL_TREE)
3704               candidate = decl;
3705         }
3706
3707       /* Now go to the upper classes, bail out if necessary.  We will
3708          analyze the returned SUPER and act accordingly (see
3709          do_resolve_class).  */
3710       if (JPRIMITIVE_TYPE_P (TREE_TYPE (enclosing))
3711           || TREE_TYPE (enclosing) == void_type_node)
3712         {
3713           parse_error_context (cl, "Qualifier must be a reference");
3714           enclosing = NULL_TREE;
3715           break;
3716         }
3717       local_super = CLASSTYPE_SUPER (TREE_TYPE (enclosing));
3718       if (!local_super || local_super == object_type_node)
3719         break;
3720
3721       if (TREE_CODE (local_super) == POINTER_TYPE)
3722         local_super = do_resolve_class (NULL, NULL, local_super, NULL, NULL);
3723       else
3724         local_super = TYPE_NAME (local_super);
3725
3726       /* We may not have checked for circular inheritance yet, so do so
3727          here to prevent an infinite loop. */
3728       if (htab_find (circularity_hash, local_super) != NULL)
3729         {
3730           if (!cl)
3731             cl = lookup_cl (enclosing);
3732
3733           parse_error_context
3734             (cl, "Cyclic inheritance involving %s",
3735              IDENTIFIER_POINTER (DECL_NAME (enclosing)));
3736           enclosing = NULL_TREE;
3737         }
3738       else
3739         enclosing = local_super;
3740     }
3741
3742   htab_delete (circularity_hash);
3743
3744   /* We failed, but we might have found a matching class that wasn't
3745      accessible.  Return that to get a better error message.  */
3746   return candidate;
3747 }
3748
3749 /* Within ENCLOSING, find a decl for NAME and return it. NAME can be
3750    qualified. */
3751
3752 static tree
3753 find_as_inner_class (tree enclosing, tree name, tree cl)
3754 {
3755   tree qual, to_return;
3756   if (!enclosing)
3757     return NULL_TREE;
3758
3759   name = TYPE_NAME (name);
3760
3761   /* First search: within the scope of `enclosing', search for name */
3762   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3763     qual = EXPR_WFL_QUALIFICATION (cl);
3764   else if (cl)
3765     qual = build_tree_list (cl, NULL_TREE);
3766   else
3767     qual = build_tree_list (build_unknown_wfl (name), NULL_TREE);
3768
3769   if ((to_return = find_as_inner_class_do (qual, enclosing)))
3770     return to_return;
3771
3772   /* We're dealing with a qualified name. Try to resolve thing until
3773      we get something that is an enclosing class. */
3774   if (QUALIFIED_P (name) && cl && EXPR_WFL_NODE (cl) == name)
3775     {
3776       tree acc = NULL_TREE, decl = NULL_TREE, ptr;
3777
3778       for (qual = EXPR_WFL_QUALIFICATION (cl); qual && !decl;
3779            qual = TREE_CHAIN (qual))
3780         {
3781           acc = merge_qualified_name (acc,
3782                                       EXPR_WFL_NODE (TREE_PURPOSE (qual)));
3783           BUILD_PTR_FROM_NAME (ptr, acc);
3784           decl = do_resolve_class (NULL_TREE, NULL_TREE, ptr, NULL_TREE, cl);
3785         }
3786
3787       /* A NULL qual and a decl means that the search ended
3788          successfully?!? We have to do something then. FIXME */
3789
3790       if (decl)
3791         enclosing = decl;
3792       else
3793         qual = EXPR_WFL_QUALIFICATION (cl);
3794     }
3795   /* Otherwise, create a qual for the other part of the resolution. */
3796   else
3797     qual = build_tree_list (build_unknown_wfl (name), NULL_TREE);
3798
3799   return find_as_inner_class_do (qual, enclosing);
3800 }
3801
3802 /* We go inside the list of sub classes and try to find a way
3803    through. */
3804
3805 static tree
3806 find_as_inner_class_do (tree qual, tree enclosing)
3807 {
3808   if (!qual)
3809     return NULL_TREE;
3810
3811   for (; qual && enclosing; qual = TREE_CHAIN (qual))
3812     {
3813       tree name_to_match = EXPR_WFL_NODE (TREE_PURPOSE (qual));
3814       tree next_enclosing = NULL_TREE;
3815       tree inner_list;
3816
3817       for (inner_list = DECL_INNER_CLASS_LIST (enclosing);
3818            inner_list; inner_list = TREE_CHAIN (inner_list))
3819         {
3820           if (TREE_VALUE (inner_list) == name_to_match)
3821             {
3822               next_enclosing = TREE_PURPOSE (inner_list);
3823               break;
3824             }
3825         }
3826       enclosing = next_enclosing;
3827     }
3828
3829   return (!qual && enclosing ? enclosing : NULL_TREE);
3830 }
3831
3832 static void
3833 link_nested_class_to_enclosing (void)
3834 {
3835   if (GET_ENCLOSING_CPC ())
3836     {
3837       tree enclosing = GET_ENCLOSING_CPC_CONTEXT ();
3838       DECL_INNER_CLASS_LIST (enclosing) =
3839         tree_cons (GET_CPC (), GET_CPC_UN (),
3840                    DECL_INNER_CLASS_LIST (enclosing));
3841     }
3842 }
3843
3844 static tree
3845 maybe_make_nested_class_name (tree name)
3846 {
3847   tree id = NULL_TREE;
3848
3849   if (CPC_INNER_P ())
3850     {
3851       /* If we're in a function, we must append a number to create the
3852          nested class name.  However, we don't do this if the class we
3853          are constructing is anonymous, because in that case we'll
3854          already have a number as the class name.  */
3855       if (! make_nested_class_name (GET_CPC_LIST ())
3856           && current_function_decl != NULL_TREE
3857           && ! ISDIGIT (IDENTIFIER_POINTER (name)[0]))
3858         {
3859           char buf[10];
3860           sprintf (buf, "%d", anonymous_class_counter);
3861           ++anonymous_class_counter;
3862           obstack_grow (&temporary_obstack, buf, strlen (buf));
3863           obstack_1grow (&temporary_obstack, '$');
3864         }
3865       obstack_grow0 (&temporary_obstack,
3866                      IDENTIFIER_POINTER (name),
3867                      IDENTIFIER_LENGTH (name));
3868       id = get_identifier (obstack_finish (&temporary_obstack));
3869       if (ctxp->package)
3870         QUALIFIED_P (id) = 1;
3871     }
3872   return id;
3873 }
3874
3875 /* If DECL is NULL, create and push a new DECL, record the current
3876    line CL and do other maintenance things.  */
3877
3878 static tree
3879 maybe_create_class_interface_decl (tree decl, tree raw_name,
3880                                    tree qualified_name, tree cl)
3881 {
3882   if (!decl)
3883     decl = push_class (make_class (), qualified_name);
3884
3885   /* Take care of the file and line business */
3886 #ifdef USE_MAPPED_LOCATION
3887   DECL_SOURCE_LOCATION (decl) = EXPR_LOCATION (cl);
3888 #else
3889   DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
3890   DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
3891 #endif
3892   CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
3893   CLASS_PARSED_P (TREE_TYPE (decl)) = 1;
3894 #ifdef USE_MAPPED_LOCATION
3895   {
3896     tree tmp = maybe_get_identifier (EXPR_FILENAME (cl));
3897     CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3898       tmp && IS_A_COMMAND_LINE_FILENAME_P (tmp);
3899   }
3900 #else
3901   CLASS_FROM_CURRENTLY_COMPILED_P (TREE_TYPE (decl)) =
3902     IS_A_COMMAND_LINE_FILENAME_P (EXPR_WFL_FILENAME_NODE (cl));
3903 #endif
3904
3905   PUSH_CPC (decl, raw_name);
3906   DECL_CONTEXT (decl) = GET_ENCLOSING_CPC_CONTEXT ();
3907
3908   /* Link the declaration to the already seen ones */
3909   TREE_CHAIN (decl) = ctxp->class_list;
3910   ctxp->class_list = decl;
3911
3912   /* Create a new nodes in the global lists */
3913   gclass_list = tree_cons (NULL_TREE, decl, gclass_list);
3914   all_class_list = tree_cons (NULL_TREE, decl, all_class_list);
3915
3916   /* Install a new dependency list element */
3917   create_jdep_list (ctxp);
3918
3919   /* We keep the compilation unit imports in the class so that
3920      they can be used later to resolve type dependencies that
3921      aren't necessary to solve now. */
3922   TYPE_IMPORT_LIST (TREE_TYPE (decl)) = ctxp->import_list;
3923   TYPE_IMPORT_DEMAND_LIST (TREE_TYPE (decl)) = ctxp->import_demand_list;
3924
3925   TYPE_PACKAGE (TREE_TYPE (decl)) = ctxp->package;
3926
3927   SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
3928                           IDENTIFIER_POINTER (qualified_name)));
3929   return decl;
3930 }
3931
3932 static void
3933 add_superinterfaces (tree decl, tree interface_list)
3934 {
3935   tree node;
3936   /* Superinterface(s): if present and defined, parser_check_super_interface ()
3937      takes care of ensuring that:
3938        - This is an accessible interface type,
3939        - Circularity detection.
3940    parser_add_interface is then called. If present but not defined,
3941    the check operation is delayed until the super interface gets
3942    defined.  */
3943   for (node = interface_list; node; node = TREE_CHAIN (node))
3944     {
3945       tree current = TREE_PURPOSE (node);
3946       tree idecl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current));
3947       if (idecl && CLASS_LOADED_P (TREE_TYPE (idecl)))
3948         {
3949           if (!parser_check_super_interface (idecl, decl, current))
3950             parser_add_interface (decl, idecl, current);
3951         }
3952       else
3953         register_incomplete_type (JDEP_INTERFACE,
3954                                   current, decl, NULL_TREE);
3955     }
3956 }
3957
3958 /* Create an interface in pass1 and return its decl. Return the
3959    interface's decl in pass 2.  */
3960
3961 static tree
3962 create_interface (int flags, tree id, tree super)
3963 {
3964   tree raw_name = EXPR_WFL_NODE (id);
3965   tree q_name = parser_qualified_classname (raw_name);
3966   tree decl = IDENTIFIER_CLASS_VALUE (q_name);
3967
3968   /* Certain syntax errors are making SUPER be like ID. Avoid this
3969      case. */
3970   if (ctxp->class_err && id == super)
3971     super = NULL;
3972
3973   EXPR_WFL_NODE (id) = q_name;  /* Keep source location, even if refined. */
3974
3975   /* Basic checks: scope, redefinition, modifiers */
3976   if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
3977     {
3978       PUSH_ERROR ();
3979       return NULL_TREE;
3980     }
3981
3982   /* Suspend the current parsing context if we're parsing an inner
3983      interface */
3984   if (CPC_INNER_P ())
3985     {
3986       java_parser_context_suspend ();
3987       /* Interface members are public. */
3988       if (CLASS_INTERFACE (GET_CPC ()))
3989         flags |= ACC_PUBLIC;
3990     }
3991
3992   /* Push a new context for (static) initialized upon declaration fields */
3993   java_parser_context_push_initialized_field ();
3994
3995   /* Interface modifiers check
3996        - public/abstract allowed (already done at that point)
3997        - abstract is obsolete (comes first, it's a warning, or should be)
3998        - Can't use twice the same (checked in the modifier rule) */
3999   if ((flags & ACC_ABSTRACT) && flag_redundant)
4000     parse_warning_context
4001       (MODIFIER_WFL (ABSTRACT_TK),
4002        "Redundant use of %<abstract%> modifier. Interface %qs is implicitly abstract", IDENTIFIER_POINTER (raw_name));
4003
4004   /* Create a new decl if DECL is NULL, otherwise fix it */
4005   decl = maybe_create_class_interface_decl (decl, raw_name, q_name, id);
4006
4007   /* Interfaces are always abstract. */
4008   flags |= ACC_ABSTRACT;
4009
4010   /* Inner interfaces are always static.  */
4011   if (INNER_CLASS_DECL_P (decl))
4012     flags |= ACC_STATIC;
4013
4014   /* Set super info and mark the class a complete */
4015   set_super_info (ACC_INTERFACE | flags, TREE_TYPE (decl),
4016                   object_type_node, ctxp->interface_number);
4017   ctxp->interface_number = 0;
4018   CLASS_COMPLETE_P (decl) = 1;
4019   add_superinterfaces (decl, super);
4020
4021   /* Eventually sets the @deprecated tag flag */
4022   CHECK_DEPRECATED (decl);
4023
4024   return decl;
4025 }
4026
4027 /* Patch anonymous class CLASS, by either extending or implementing
4028    DEP.  */
4029
4030 static void
4031 patch_anonymous_class (tree type_decl, tree class_decl, tree wfl)
4032 {
4033   tree class = TREE_TYPE (class_decl);
4034   tree type =  TREE_TYPE (type_decl);
4035   tree binfo = TYPE_BINFO (class);
4036
4037   /* If it's an interface, implement it */
4038   if (CLASS_INTERFACE (type_decl))
4039     {
4040       if (parser_check_super_interface (type_decl, class_decl, wfl))
4041         return;
4042
4043       if (!VEC_space (tree, BINFO_BASE_BINFOS (binfo), 1))
4044         {
4045            /* Extend the binfo - by reallocating and copying it. */
4046           tree new_binfo;
4047           tree base_binfo;
4048           int i;
4049
4050           new_binfo = make_tree_binfo ((BINFO_N_BASE_BINFOS (binfo) + 1) * 2);
4051           for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4052             BINFO_BASE_APPEND (new_binfo, base_binfo);
4053           CLASS_HAS_SUPER_FLAG (new_binfo) = CLASS_HAS_SUPER_FLAG (binfo);
4054           BINFO_VTABLE (new_binfo) = BINFO_VTABLE (binfo);
4055           TYPE_BINFO (class) = new_binfo;
4056         }
4057
4058       /* And add the interface */
4059       parser_add_interface (class_decl, type_decl, wfl);
4060     }
4061   /* Otherwise, it's a type we want to extend */
4062   else
4063     {
4064       if (parser_check_super (type_decl, class_decl, wfl))
4065         return;
4066       BINFO_TYPE (BINFO_BASE_BINFO (binfo, 0)) = type;
4067     }
4068 }
4069
4070 /* Create an anonymous class which extends/implements TYPE_NAME, and return
4071    its decl.  */
4072
4073 static tree
4074 create_anonymous_class (tree type_name)
4075 {
4076   char buffer [80];
4077   tree super = NULL_TREE, itf = NULL_TREE;
4078   tree id, type_decl, class;
4079
4080   /* The unqualified name of the anonymous class. It's just a number. */
4081   sprintf (buffer, "%d", anonymous_class_counter++);
4082   id = build_wfl_node (get_identifier (buffer));
4083   EXPR_WFL_LINECOL (id) = EXPR_WFL_LINECOL (type_name);
4084
4085   /* We know about the type to extend/implement. We go ahead */
4086   if ((type_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (type_name))))
4087     {
4088       /* Create a class which either implements on extends the designated
4089          class. The class bears an inaccessible name. */
4090       if (CLASS_INTERFACE (type_decl))
4091         {
4092           /* It's OK to modify it here. It's been already used and
4093              shouldn't be reused */
4094           ctxp->interface_number = 1;
4095           /* Interfaces should presented as a list of WFLs */
4096           itf = build_tree_list (type_name, NULL_TREE);
4097         }
4098       else
4099         super = type_name;
4100     }
4101
4102   class = create_class (ACC_FINAL, id, super, itf);
4103
4104   /* We didn't know anything about the stuff. We register a dependence. */
4105   if (!type_decl)
4106     register_incomplete_type (JDEP_ANONYMOUS, type_name, class, NULL_TREE);
4107
4108   ANONYMOUS_CLASS_P (TREE_TYPE (class)) = 1;
4109   return class;
4110 }
4111
4112 /* Create a class in pass1 and return its decl. Return class
4113    interface's decl in pass 2.  */
4114
4115 static tree
4116 create_class (int flags, tree id, tree super, tree interfaces)
4117 {
4118   tree raw_name = EXPR_WFL_NODE (id);
4119   tree class_id, decl;
4120   tree super_decl_type;
4121
4122   /* Certain syntax errors are making SUPER be like ID. Avoid this
4123      case. */
4124   if (ctxp->class_err && id == super)
4125     super = NULL;
4126
4127   class_id = parser_qualified_classname (raw_name);
4128   decl = IDENTIFIER_CLASS_VALUE (class_id);
4129   EXPR_WFL_NODE (id) = class_id;
4130
4131   /* Basic check: scope, redefinition, modifiers */
4132   if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
4133     {
4134       PUSH_ERROR ();
4135       return NULL_TREE;
4136     }
4137
4138   /* Suspend the current parsing context if we're parsing an inner
4139      class or an anonymous class. */
4140   if (CPC_INNER_P ())
4141     {
4142       java_parser_context_suspend ();
4143       /* Interface members are public. */
4144       if (CLASS_INTERFACE (GET_CPC ()))
4145         flags |= ACC_PUBLIC;
4146     }
4147
4148   /* Push a new context for (static) initialized upon declaration fields */
4149   java_parser_context_push_initialized_field ();
4150
4151   /* Class modifier check:
4152        - Allowed modifier (already done at that point)
4153        - abstract AND final forbidden
4154        - Public classes defined in the correct file */
4155   if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
4156     parse_error_context
4157       (id, "Class %qs can't be declared both abstract and final",
4158        IDENTIFIER_POINTER (raw_name));
4159
4160   /* Create a new decl if DECL is NULL, otherwise fix it */
4161   decl = maybe_create_class_interface_decl (decl, raw_name, class_id, id);
4162
4163   /* If SUPER exists, use it, otherwise use Object */
4164   if (super)
4165     {
4166       /* java.lang.Object can't extend anything.  */
4167       if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
4168         {
4169           parse_error_context (id, "%<java.lang.Object%> can't extend anything");
4170           return NULL_TREE;
4171         }
4172
4173       super_decl_type =
4174         register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
4175     }
4176   else if (TREE_TYPE (decl) != object_type_node)
4177     super_decl_type = object_type_node;
4178   /* We're defining java.lang.Object */
4179   else
4180     super_decl_type = NULL_TREE;
4181
4182   /* A class nested in an interface is implicitly static. */
4183   if (INNER_CLASS_DECL_P (decl)
4184       && CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (DECL_CONTEXT (decl)))))
4185     {
4186       flags |= ACC_STATIC;
4187     }
4188
4189   /* Set super info and mark the class as complete. */
4190   set_super_info (flags, TREE_TYPE (decl), super_decl_type,
4191                   ctxp->interface_number);
4192   ctxp->interface_number = 0;
4193   CLASS_COMPLETE_P (decl) = 1;
4194   add_superinterfaces (decl, interfaces);
4195
4196   /* TYPE_VFIELD' is a compiler-generated field used to point to
4197      virtual function tables.  In gcj, every class has a common base
4198      virtual function table in java.lang.object.  */
4199   TYPE_VFIELD (TREE_TYPE (decl)) = TYPE_VFIELD (object_type_node);
4200
4201   /* Add the private this$<n> field, Replicate final locals still in
4202      scope as private final fields mangled like val$<local_name>.
4203      This does not occur for top level (static) inner classes. */
4204   if (PURE_INNER_CLASS_DECL_P (decl))
4205     add_inner_class_fields (decl, current_function_decl);
4206
4207   /* Eventually sets the @deprecated tag flag */
4208   CHECK_DEPRECATED (decl);
4209
4210   /* Reset the anonymous class counter when declaring non inner classes */
4211   if (!INNER_CLASS_DECL_P (decl))
4212     anonymous_class_counter = 1;
4213
4214   return decl;
4215 }
4216
4217 /* End a class declaration: register the statements used to create
4218    finit$ and <clinit>, pop the current class and resume the prior
4219    parser context if necessary.  */
4220
4221 static void
4222 end_class_declaration (int resume)
4223 {
4224   /* If an error occurred, context weren't pushed and won't need to be
4225      popped by a resume. */
4226   int no_error_occurred = ctxp->next && GET_CPC () != error_mark_node;
4227
4228   if (GET_CPC () != error_mark_node)
4229     dump_java_tree (TDI_class, GET_CPC ());
4230
4231   java_parser_context_pop_initialized_field ();
4232   POP_CPC ();
4233   if (resume && no_error_occurred)
4234     java_parser_context_resume ();
4235
4236   /* We're ending a class declaration, this is a good time to reset
4237      the interface cout. Note that might have been already done in
4238      create_interface, but if at that time an inner class was being
4239      dealt with, the interface count was reset in a context created
4240      for the sake of handling inner classes declaration. */
4241   ctxp->interface_number = 0;
4242 }
4243
4244 static void
4245 add_inner_class_fields (tree class_decl, tree fct_decl)
4246 {
4247   tree block, marker, f;
4248
4249   f = add_field (TREE_TYPE (class_decl),
4250                  build_current_thisn (TREE_TYPE (class_decl)),
4251                  build_pointer_type (TREE_TYPE (DECL_CONTEXT (class_decl))),
4252                  ACC_PRIVATE);
4253   FIELD_THISN (f) = 1;
4254
4255   if (!fct_decl)
4256     return;
4257
4258   for (block = GET_CURRENT_BLOCK (fct_decl);
4259        block && TREE_CODE (block) == BLOCK; block = BLOCK_SUPERCONTEXT (block))
4260     {
4261       tree decl;
4262       for (decl = BLOCK_EXPR_DECLS (block); decl; decl = TREE_CHAIN (decl))
4263         {
4264           tree name, pname;
4265           tree wfl, init, list;
4266
4267           /* Avoid non final arguments. */
4268           if (!LOCAL_FINAL_P (decl))
4269             continue;
4270
4271           MANGLE_OUTER_LOCAL_VARIABLE_NAME (name, DECL_NAME (decl));
4272           MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_ID (pname, DECL_NAME (decl));
4273           wfl = build_wfl_node (name);
4274           init = build_wfl_node (pname);
4275           /* Build an initialization for the field: it will be
4276              initialized by a parameter added to finit$, bearing a
4277              mangled name of the field itself (param$<n>.) The
4278              parameter is provided to finit$ by the constructor
4279              invoking it (hence the constructor will also feature a
4280              hidden parameter, set to the value of the outer context
4281              local at the time the inner class is created.)
4282
4283              Note: we take into account all possible locals that can
4284              be accessed by the inner class. It's actually not trivial
4285              to minimize these aliases down to the ones really
4286              used. One way to do that would be to expand all regular
4287              methods first, then finit$ to get a picture of what's
4288              used.  It works with the exception that we would have to
4289              go back on all constructor invoked in regular methods to
4290              have their invocation reworked (to include the right amount
4291              of alias initializer parameters.)
4292
4293              The only real way around, I think, is a first pass to
4294              identify locals really used in the inner class. We leave
4295              the flag FIELD_LOCAL_ALIAS_USED around for that future
4296              use.
4297
4298              On the other hand, it only affect local inner classes,
4299              whose constructors (and finit$ call) will be featuring
4300              unnecessary arguments. It's easy for a developer to keep
4301              this number of parameter down by using the `final'
4302              keyword only when necessary. For the time being, we can
4303              issue a warning on unnecessary finals. FIXME */
4304           init = build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (wfl),
4305                                    wfl, init);
4306
4307           /* Register the field. The TREE_LIST holding the part
4308              initialized/initializer will be marked ARG_FINAL_P so
4309              that the created field can be marked
4310              FIELD_LOCAL_ALIAS. */
4311           list = build_tree_list (wfl, init);
4312           ARG_FINAL_P (list) = 1;
4313           register_fields (ACC_PRIVATE | ACC_FINAL, TREE_TYPE (decl), list);
4314         }
4315     }
4316
4317   if (!CPC_INITIALIZER_STMT (ctxp))
4318     return;
4319
4320   /* If we ever registered an alias field, insert and marker to
4321      remember where the list ends. The second part of the list (the one
4322      featuring initialized fields) so it can be later reversed to
4323      enforce 8.5. The marker will be removed during that operation. */
4324   marker = build_tree_list (NULL_TREE, NULL_TREE);
4325   TREE_CHAIN (marker) = CPC_INITIALIZER_STMT (ctxp);
4326   SET_CPC_INITIALIZER_STMT (ctxp, marker);
4327 }
4328
4329 /* Can't use lookup_field () since we don't want to load the class and
4330    can't set the CLASS_LOADED_P flag */
4331
4332 static tree
4333 find_field (tree class, tree name)
4334 {
4335   tree decl;
4336   for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
4337     {
4338       if (DECL_NAME (decl) == name)
4339         return decl;
4340     }
4341   return NULL_TREE;
4342 }
4343
4344 /* Wrap around lookup_field that doesn't potentially upset the value
4345    of CLASS */
4346
4347 static tree
4348 lookup_field_wrapper (tree class, tree name)
4349 {
4350   tree type = class;
4351   tree decl = NULL_TREE;
4352   java_parser_context_save_global ();
4353
4354   /* Last chance: if we're within the context of an inner class, we
4355      might be trying to access a local variable defined in an outer
4356      context. We try to look for it now. */
4357   if (INNER_CLASS_TYPE_P (class) && TREE_CODE (name) == IDENTIFIER_NODE)
4358     {
4359       tree new_name;
4360       MANGLE_OUTER_LOCAL_VARIABLE_NAME (new_name, name);
4361       decl = lookup_field (&type, new_name);
4362       if (decl && decl != error_mark_node)
4363         FIELD_LOCAL_ALIAS_USED (decl) = 1;
4364     }
4365   if (!decl || decl == error_mark_node)
4366     {
4367       type = class;
4368       decl = lookup_field (&type, name);
4369     }
4370
4371   /* If the field still hasn't been found, try the next enclosing context. */
4372   if (!decl && INNER_CLASS_TYPE_P (class))
4373     {
4374       tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class)));
4375       decl = lookup_field_wrapper (outer_type, name);
4376     }
4377
4378   java_parser_context_restore_global ();
4379   return decl == error_mark_node ? NULL : decl;
4380 }
4381
4382 /* Find duplicate field within the same class declarations and report
4383    the error. Returns 1 if a duplicated field was found, 0
4384    otherwise.  */
4385
4386 static int
4387 duplicate_declaration_error_p (tree new_field_name, tree new_type, tree cl)
4388 {
4389   /* This might be modified to work with method decl as well */
4390   tree decl = find_field (TREE_TYPE (GET_CPC ()), new_field_name);
4391   if (decl)
4392     {
4393       char *t1 = xstrdup (purify_type_name
4394                          ((TREE_CODE (new_type) == POINTER_TYPE
4395                            && TREE_TYPE (new_type) == NULL_TREE) ?
4396                           IDENTIFIER_POINTER (TYPE_NAME (new_type)) :
4397                           lang_printable_name (new_type, 1)));
4398       /* The type may not have been completed by the time we report
4399          the error */
4400       char *t2 = xstrdup (purify_type_name
4401                          ((TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
4402                            && TREE_TYPE (TREE_TYPE (decl)) == NULL_TREE) ?
4403                           IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))) :
4404                           lang_printable_name (TREE_TYPE (decl), 1)));
4405       parse_error_context
4406         (cl, "Duplicate variable declaration: %<%s %s%> was %<%s %s%> (%s:%d)",
4407          t1, IDENTIFIER_POINTER (new_field_name),
4408          t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
4409          DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4410       free (t1);
4411       free (t2);
4412       return 1;
4413     }
4414   return 0;
4415 }
4416
4417 /* Field registration routine. If TYPE doesn't exist, field
4418    declarations are linked to the undefined TYPE dependency list, to
4419    be later resolved in java_complete_class () */
4420
4421 static void
4422 register_fields (int flags, tree type, tree variable_list)
4423 {
4424   tree current, saved_type;
4425   tree class_type = NULL_TREE;
4426   location_t saved_location = input_location;
4427   int must_chain = 0;
4428   tree wfl = NULL_TREE;
4429
4430   if (GET_CPC ())
4431     class_type = TREE_TYPE (GET_CPC ());
4432
4433   if (!class_type || class_type == error_mark_node)
4434     return;
4435
4436   /* If we're adding fields to interfaces, those fields are public,
4437      static, final */
4438   if (CLASS_INTERFACE (TYPE_NAME (class_type)))
4439     {
4440       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
4441                                  flags, ACC_PUBLIC, "interface field(s)");
4442       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
4443                                  flags, ACC_STATIC, "interface field(s)");
4444       OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
4445                                  flags, ACC_FINAL, "interface field(s)");
4446       check_modifiers ("Illegal interface member modifier %qs", flags,
4447                        INTERFACE_FIELD_MODIFIERS);
4448       flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
4449     }
4450
4451   /* Obtain a suitable type for resolution, if necessary */
4452   SET_TYPE_FOR_RESOLUTION (type, wfl, must_chain);
4453
4454   /* If TYPE is fully resolved and we don't have a reference, make one */
4455   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4456
4457   for (current = variable_list, saved_type = type; current;
4458        current = TREE_CHAIN (current), type = saved_type)
4459     {
4460       tree real_type;
4461       tree field_decl;
4462       tree cl = TREE_PURPOSE (current);
4463       tree init = TREE_VALUE (current);
4464       tree current_name = EXPR_WFL_NODE (cl);
4465
4466       /* Can't declare non-final static fields in inner classes */
4467       if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (class_type)
4468           && !(flags & ACC_FINAL))
4469         parse_error_context
4470           (cl, "Field %qs can't be static in inner class %qs unless it is final",
4471            IDENTIFIER_POINTER (EXPR_WFL_NODE (cl)),
4472            lang_printable_name (class_type, 0));
4473
4474       /* Process NAME, as it may specify extra dimension(s) for it */
4475       type = build_array_from_name (type, wfl, current_name, &current_name);
4476
4477       /* Type adjustment. We may have just readjusted TYPE because
4478          the variable specified more dimensions. Make sure we have
4479          a reference if we can and don't have one already. Also
4480          change the name if we have an init. */
4481       if (type != saved_type)
4482         {
4483           PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4484           if (init)
4485             EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = current_name;
4486         }
4487
4488       real_type = GET_REAL_TYPE (type);
4489       /* Check for redeclarations */
4490       if (duplicate_declaration_error_p (current_name, real_type, cl))
4491         continue;
4492
4493       /* Set input_line to the line the field was found and create a
4494          declaration for it. Eventually sets the @deprecated tag flag. */
4495 #ifdef USE_MAPPED_LOCATION
4496       input_location = EXPR_LOCATION (cl);
4497 #else
4498       input_line = EXPR_WFL_LINENO (cl);
4499 #endif
4500       field_decl = add_field (class_type, current_name, real_type, flags);
4501       CHECK_DEPRECATED_NO_RESET (field_decl);
4502
4503       /* If the field denotes a final instance variable, then we
4504          allocate a LANG_DECL_SPECIFIC part to keep track of its
4505          initialization. We also mark whether the field was
4506          initialized upon its declaration. We don't do that if the
4507          created field is an alias to a final local. */
4508       if (!ARG_FINAL_P (current) && (flags & ACC_FINAL))
4509         {
4510           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field_decl);
4511           DECL_FIELD_FINAL_WFL (field_decl) = cl;
4512         }
4513
4514       /* If the couple initializer/initialized is marked ARG_FINAL_P,
4515          we mark the created field FIELD_LOCAL_ALIAS, so that we can
4516          hide parameters to this inner class finit$ and
4517          constructors. It also means that the field isn't final per
4518          say. */
4519       if (ARG_FINAL_P (current))
4520         {
4521           FIELD_LOCAL_ALIAS (field_decl) = 1;
4522           FIELD_FINAL (field_decl) = 0;
4523         }
4524
4525       /* Check if we must chain. */
4526       if (must_chain)
4527         register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
4528
4529       /* If we have an initialization value tied to the field */
4530       if (init)
4531         {
4532           /* The field is declared static */
4533           if (flags & ACC_STATIC)
4534             {
4535               /* We include the field and its initialization part into
4536                  a list used to generate <clinit>. After <clinit> is
4537                  walked, field initializations will be processed and
4538                  fields initialized with known constants will be taken
4539                  out of <clinit> and have their DECL_INITIAL set
4540                  appropriately. */
4541               TREE_CHAIN (init) = CPC_STATIC_INITIALIZER_STMT (ctxp);
4542               SET_CPC_STATIC_INITIALIZER_STMT (ctxp, init);
4543               if (TREE_OPERAND (init, 1)
4544                   && TREE_CODE (TREE_OPERAND (init, 1)) == NEW_ARRAY_INIT)
4545                 TREE_STATIC (TREE_OPERAND (init, 1)) = 1;
4546             }
4547           /* A non-static field declared with an immediate initialization is
4548              to be initialized in <init>, if any.  This field is remembered
4549              to be processed at the time of the generation of <init>. */
4550           else
4551             {
4552               TREE_CHAIN (init) = CPC_INITIALIZER_STMT (ctxp);
4553               SET_CPC_INITIALIZER_STMT (ctxp, init);
4554             }
4555           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
4556           DECL_INITIAL (field_decl) = TREE_OPERAND (init, 1);
4557         }
4558     }
4559
4560   CLEAR_DEPRECATED;
4561   input_location = saved_location;
4562 }
4563
4564 /* Generate finit$, using the list of initialized fields to populate
4565    its body. finit$'s parameter(s) list is adjusted to include the
4566    one(s) used to initialized the field(s) caching outer context
4567    local(s).  */
4568
4569 static tree
4570 generate_finit (tree class_type)
4571 {
4572   int count = 0;
4573   tree list = TYPE_FINIT_STMT_LIST (class_type);
4574   tree mdecl, current, parms;
4575
4576   parms = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
4577                                                   class_type, NULL_TREE,
4578                                                   &count);
4579   CRAFTED_PARAM_LIST_FIXUP (parms);
4580   mdecl = create_artificial_method (class_type, ACC_PRIVATE, void_type_node,
4581                                     finit_identifier_node, parms);
4582   fix_method_argument_names (parms, mdecl);
4583   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4584                        mdecl, NULL_TREE);
4585   DECL_FUNCTION_NAP (mdecl) = count;
4586   start_artificial_method_body (mdecl);
4587
4588   for (current = list; current; current = TREE_CHAIN (current))
4589     java_method_add_stmt (mdecl,
4590                           build_debugable_stmt (EXPR_WFL_LINECOL (current),
4591                                                 current));
4592   end_artificial_method_body (mdecl);
4593   return mdecl;
4594 }
4595
4596 /* Generate a function to run the instance initialization code. The
4597    private method is called `instinit$'. Unless we're dealing with an
4598    anonymous class, we determine whether all ctors of CLASS_TYPE
4599    declare a checked exception in their `throws' clause in order to
4600    see whether it's necessary to encapsulate the instance initializer
4601    statements in a try/catch/rethrow sequence.  */
4602
4603 static tree
4604 generate_instinit (tree class_type)
4605 {
4606   tree current;
4607   tree compound = NULL_TREE;
4608   tree parms = tree_cons (this_identifier_node,
4609                           build_pointer_type (class_type), end_params_node);
4610   tree mdecl = create_artificial_method (class_type, ACC_PRIVATE,
4611                                          void_type_node,
4612                                          instinit_identifier_node, parms);
4613
4614   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
4615                        mdecl, NULL_TREE);
4616
4617   /* Gather all the statements in a compound */
4618   for (current = TYPE_II_STMT_LIST (class_type);
4619        current; current = TREE_CHAIN (current))
4620     compound = add_stmt_to_compound (compound, NULL_TREE, current);
4621
4622   /* We need to encapsulate COMPOUND by a try/catch statement to
4623      rethrow exceptions that might occur in the instance initializer.
4624      We do that only if all ctors of CLASS_TYPE are set to catch a
4625      checked exception. This doesn't apply to anonymous classes (since
4626      they don't have declared ctors.) */
4627   if (!ANONYMOUS_CLASS_P (class_type) &&
4628       ctors_unchecked_throws_clause_p (class_type))
4629     {
4630       compound = encapsulate_with_try_catch (0, exception_type_node, compound,
4631                                              build1 (THROW_EXPR, NULL_TREE,
4632                                                      build_wfl_node (wpv_id)));
4633       DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE,
4634                                                       exception_type_node);
4635     }
4636
4637   start_artificial_method_body (mdecl);
4638   java_method_add_stmt (mdecl, compound);
4639   end_artificial_method_body (mdecl);
4640
4641   return mdecl;
4642 }
4643
4644 /* FIXME */
4645 static tree
4646 build_instinit_invocation (tree class_type)
4647 {
4648   tree to_return = NULL_TREE;
4649
4650   if (TYPE_II_STMT_LIST (class_type))
4651     {
4652       tree parm = build_tree_list (NULL_TREE,
4653                                    build_wfl_node (this_identifier_node));
4654       to_return =
4655         build_method_invocation (build_wfl_node (instinit_identifier_node),
4656                                  parm);
4657     }
4658   return to_return;
4659 }
4660
4661 /* Shared across method_declarator and method_header to remember the
4662    patch stage that was reached during the declaration of the method.
4663    A method DECL is built differently is there is no patch
4664    (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
4665    pending on the currently defined method.  */
4666
4667 static int patch_stage;
4668
4669 /* Check the method declaration and add the method to its current
4670    class.  If the argument list is known to contain incomplete types,
4671    the method is partially added and the registration will be resume
4672    once the method arguments resolved. If TYPE is NULL, we're dealing
4673    with a constructor.  */
4674
4675 static tree
4676 method_header (int flags, tree type, tree mdecl, tree throws)
4677 {
4678   tree type_wfl = NULL_TREE;
4679   tree meth_name = NULL_TREE;
4680   tree current, orig_arg, this_class = NULL;
4681   tree id, meth;
4682   location_t saved_location;
4683   int constructor_ok = 0, must_chain;
4684   int count;
4685
4686   if (mdecl == error_mark_node)
4687     return error_mark_node;
4688   meth = TREE_VALUE (mdecl);
4689   id = TREE_PURPOSE (mdecl);
4690
4691   check_modifiers_consistency (flags);
4692
4693   if (GET_CPC ())
4694     this_class = TREE_TYPE (GET_CPC ());
4695
4696   if (!this_class || this_class == error_mark_node)
4697     return NULL_TREE;
4698
4699   /* There are some forbidden modifiers for an abstract method and its
4700      class must be abstract as well.  */
4701   if (type && (flags & ACC_ABSTRACT))
4702     {
4703       ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
4704       ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
4705       ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
4706       ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
4707       ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED, id, "Synchronized");
4708       ABSTRACT_CHECK (flags, ACC_STRICT, id, "Strictfp");
4709       if (!CLASS_ABSTRACT (TYPE_NAME (this_class))
4710           && !CLASS_INTERFACE (TYPE_NAME (this_class)))
4711         parse_error_context
4712           (id,
4713            "Class %qs must be declared abstract to define abstract method %qs",
4714            IDENTIFIER_POINTER (DECL_NAME (GET_CPC ())),
4715            IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4716     }
4717
4718   /* A native method can't be strictfp.  */
4719   if ((flags & ACC_NATIVE) && (flags & ACC_STRICT))
4720     parse_error_context (id, "native method %qs can't be strictfp",
4721                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4722   /* No such thing as a transient or volatile method.  */
4723   if ((flags & ACC_TRANSIENT))
4724     parse_error_context (id, "method %qs can't be transient",
4725                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4726   if ((flags & ACC_VOLATILE))
4727     parse_error_context (id, "method %qs can't be volatile",
4728                          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
4729
4730   /* Things to be checked when declaring a constructor */
4731   if (!type)
4732     {
4733       int ec = java_error_count;
4734       /* 8.6: Constructor declarations: we might be trying to define a
4735          method without specifying a return type. */
4736       if (EXPR_WFL_NODE (id) != GET_CPC_UN ())
4737         parse_error_context
4738           (id, "Invalid method declaration, return type required");
4739       /* 8.6.3: Constructor modifiers */
4740       else
4741         {
4742           JCONSTRUCTOR_CHECK (flags, ACC_ABSTRACT, id, "abstract");
4743           JCONSTRUCTOR_CHECK (flags, ACC_STATIC, id, "static");
4744           JCONSTRUCTOR_CHECK (flags, ACC_FINAL, id, "final");
4745           JCONSTRUCTOR_CHECK (flags, ACC_NATIVE, id, "native");
4746           JCONSTRUCTOR_CHECK (flags, ACC_SYNCHRONIZED, id, "synchronized");
4747           JCONSTRUCTOR_CHECK (flags, ACC_STRICT, id, "strictfp");
4748         }
4749       /* If we found error here, we don't consider it's OK to tread
4750          the method definition as a constructor, for the rest of this
4751          function */
4752       if (ec == java_error_count)
4753         constructor_ok = 1;
4754     }
4755
4756   /* Method declared within the scope of an interface are implicitly
4757      abstract and public. Conflicts with other erroneously provided
4758      modifiers are checked right after. */
4759
4760   if (CLASS_INTERFACE (TYPE_NAME (this_class)))
4761     {
4762       /* If FLAGS isn't set because of a modifier, turn the
4763          corresponding modifier WFL to NULL so we issue a warning on
4764          the obsolete use of the modifier */
4765       if (!(flags & ACC_PUBLIC))
4766         MODIFIER_WFL (PUBLIC_TK) = NULL;
4767       if (!(flags & ACC_ABSTRACT))
4768         MODIFIER_WFL (ABSTRACT_TK) = NULL;
4769       flags |= ACC_PUBLIC;
4770       flags |= ACC_ABSTRACT;
4771     }
4772
4773   /* Inner class can't declare static methods */
4774   if ((flags & ACC_STATIC) && !TOPLEVEL_CLASS_TYPE_P (this_class))
4775     {
4776       parse_error_context
4777         (id, "Method %qs can't be static in inner class %qs. Only members of interfaces and top-level classes can be static",
4778          IDENTIFIER_POINTER (EXPR_WFL_NODE (id)),
4779          lang_printable_name (this_class, 0));
4780     }
4781
4782   /* Modifiers context reset moved up, so abstract method declaration
4783      modifiers can be later checked.  */
4784
4785   /* Set constructor returned type to void and method name to <init>,
4786      unless we found an error identifier the constructor (in which
4787      case we retain the original name) */
4788   if (!type)
4789     {
4790       type = void_type_node;
4791       if (constructor_ok)
4792         meth_name = init_identifier_node;
4793     }
4794   else
4795     meth_name = EXPR_WFL_NODE (id);
4796
4797   /* Do the returned type resolution and registration if necessary */
4798   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
4799
4800   if (meth_name)
4801     type = build_array_from_name (type, type_wfl, meth_name, &meth_name);
4802   EXPR_WFL_NODE (id) = meth_name;
4803   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
4804
4805   if (must_chain)
4806     {
4807       patch_stage = JDEP_METHOD_RETURN;
4808       register_incomplete_type (patch_stage, type_wfl, id, type);
4809       TREE_TYPE (meth) = GET_REAL_TYPE (type);
4810     }
4811   else
4812     TREE_TYPE (meth) = type;
4813
4814   saved_location = input_location;
4815   /* When defining an abstract or interface method, the curly
4816      bracket at level 1 doesn't exist because there is no function
4817      body */
4818 #ifdef USE_MAPPED_LOCATION
4819   input_location = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
4820                     EXPR_LOCATION (id));
4821 #else
4822   input_line = (ctxp->first_ccb_indent1 ? (int) ctxp->first_ccb_indent1 :
4823                 EXPR_WFL_LINENO (id));
4824 #endif
4825
4826   /* Remember the original argument list */
4827   orig_arg = TYPE_ARG_TYPES (meth);
4828
4829   if (patch_stage)              /* includes ret type and/or all args */
4830     {
4831       jdep *jdep;
4832       meth = add_method_1 (this_class, flags, meth_name, meth);
4833       /* Patch for the return type */
4834       if (patch_stage == JDEP_METHOD_RETURN)
4835         {
4836           jdep = CLASSD_LAST (ctxp->classd_list);
4837           JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
4838         }
4839       /* This is the stop JDEP. METH allows the function's signature
4840          to be computed. */
4841       register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
4842     }
4843   else
4844     meth = add_method (this_class, flags, meth_name,
4845                        build_java_signature (meth));
4846
4847   /* Remember final parameters */
4848   MARK_FINAL_PARMS (meth, orig_arg);
4849
4850   /* Fix the method argument list so we have the argument name
4851      information */
4852   fix_method_argument_names (orig_arg, meth);
4853
4854   /* Register the parameter number and re-install the current line
4855      number */
4856   DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
4857   input_location = saved_location;
4858
4859   /* Register exception specified by the `throws' keyword for
4860      resolution and set the method decl appropriate field to the list.
4861      Note: the grammar ensures that what we get here are class
4862      types. */
4863   if (throws)
4864     {
4865       throws = nreverse (throws);
4866       for (current = throws; current; current = TREE_CHAIN (current))
4867         {
4868           register_incomplete_type (JDEP_EXCEPTION, TREE_VALUE (current),
4869                                     NULL_TREE, NULL_TREE);
4870           JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
4871             &TREE_VALUE (current);
4872         }
4873       DECL_FUNCTION_THROWS (meth) = throws;
4874     }
4875
4876   if (TREE_TYPE (GET_CPC ()) != object_type_node)
4877     DECL_FUNCTION_WFL (meth) = id;
4878
4879   /* Set the flag if we correctly processed a constructor */
4880   if (constructor_ok)
4881     {
4882       DECL_CONSTRUCTOR_P (meth) = 1;
4883       /* Compute and store the number of artificial parameters declared
4884          for this constructor */
4885       for (count = 0, current = TYPE_FIELDS (this_class); current;
4886            current = TREE_CHAIN (current))
4887         if (FIELD_LOCAL_ALIAS (current))
4888           count++;
4889       DECL_FUNCTION_NAP (meth) = count;
4890     }
4891
4892   /* Eventually set the @deprecated tag flag */
4893   CHECK_DEPRECATED (meth);
4894
4895   return meth;
4896 }
4897
4898 static void
4899 fix_method_argument_names (tree orig_arg, tree meth)
4900 {
4901   tree arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
4902   if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
4903     {
4904       TREE_PURPOSE (arg) = this_identifier_node;
4905       arg = TREE_CHAIN (arg);
4906     }
4907   while (orig_arg != end_params_node)
4908     {
4909       TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
4910       orig_arg = TREE_CHAIN (orig_arg);
4911       arg = TREE_CHAIN (arg);
4912     }
4913 }
4914
4915 /* Complete the method declaration with METHOD_BODY.  */
4916
4917 static void
4918 finish_method_declaration (tree method_body)
4919 {
4920   int flags;
4921
4922   if (!current_function_decl)
4923     return;
4924
4925   flags = get_access_flags_from_decl (current_function_decl);
4926
4927   /* 8.4.5 Method Body */
4928   if ((flags & ACC_ABSTRACT || flags & ACC_NATIVE) && method_body)
4929     {
4930       tree name = DECL_NAME (current_function_decl);
4931       parse_error_context (DECL_FUNCTION_WFL (current_function_decl),
4932                            "%s method %qs can't have a body defined",
4933                            (METHOD_NATIVE (current_function_decl) ?
4934                             "Native" : "Abstract"),
4935                            IDENTIFIER_POINTER (name));
4936       method_body = NULL_TREE;
4937     }
4938   else if (!(flags & ACC_ABSTRACT) && !(flags & ACC_NATIVE) && !method_body)
4939     {
4940       tree name = DECL_NAME (current_function_decl);
4941       parse_error_context
4942         (DECL_FUNCTION_WFL (current_function_decl),
4943          "Non native and non abstract method %qs must have a body defined",
4944          IDENTIFIER_POINTER (name));
4945       method_body = NULL_TREE;
4946     }
4947
4948   if (flag_emit_class_files && method_body
4949       && TREE_CODE (method_body) == NOP_EXPR
4950       && TREE_TYPE (current_function_decl)
4951       && TREE_TYPE (TREE_TYPE (current_function_decl)) == void_type_node)
4952     method_body = build1 (RETURN_EXPR, void_type_node, NULL);
4953
4954   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)) = method_body;
4955   maybe_absorb_scoping_blocks ();
4956   /* Exit function's body */
4957   exit_block ();
4958   /* Merge last line of the function with first line, directly in the
4959      function decl. It will be used to emit correct debug info. */
4960   DECL_FUNCTION_LAST_LINE (current_function_decl) = ctxp->last_ccb_indent1;
4961
4962   /* Since function's argument's list are shared, reset the
4963      ARG_FINAL_P parameter that might have been set on some of this
4964      function parameters. */
4965   UNMARK_FINAL_PARMS (current_function_decl);
4966
4967   /* So we don't have an irrelevant function declaration context for
4968      the next static block we'll see. */
4969   current_function_decl = NULL_TREE;
4970 }
4971
4972 /* Build a an error message for constructor circularity errors.  */
4973
4974 static char *
4975 constructor_circularity_msg (tree from, tree to)
4976 {
4977   static char string [4096];
4978   char *t = xstrdup (lang_printable_name (from, 2));
4979   sprintf (string, "'%s' invokes '%s'", t, lang_printable_name (to, 2));
4980   free (t);
4981   return string;
4982 }
4983
4984 /* Verify a circular call to METH. Return 1 if an error is found, 0
4985    otherwise.  */
4986
4987 static GTY(()) tree vcc_list;
4988 static int
4989 verify_constructor_circularity (tree meth, tree current)
4990 {
4991   tree c;
4992
4993   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
4994     {
4995       if (TREE_VALUE (c) == meth)
4996         {
4997           char *t;
4998           if (vcc_list)
4999             {
5000               tree liste;
5001               vcc_list = nreverse (vcc_list);
5002               for (liste = vcc_list; liste; liste = TREE_CHAIN (liste))
5003                 {
5004                   parse_error_context
5005                     (TREE_PURPOSE (TREE_PURPOSE (liste)), "%s",
5006                      constructor_circularity_msg
5007                       (TREE_VALUE (liste), TREE_VALUE (TREE_PURPOSE (liste))));
5008                   java_error_count--;
5009                 }
5010             }
5011           t = xstrdup (lang_printable_name (meth, 2));
5012           parse_error_context (TREE_PURPOSE (c),
5013                                "%s: recursive invocation of constructor %qs",
5014                                constructor_circularity_msg (current, meth), t);
5015           free (t);
5016           vcc_list = NULL_TREE;
5017           return 1;
5018         }
5019     }
5020   for (c = DECL_CONSTRUCTOR_CALLS (current); c; c = TREE_CHAIN (c))
5021     {
5022       vcc_list = tree_cons (c, current, vcc_list);
5023       if (verify_constructor_circularity (meth, TREE_VALUE (c)))
5024         return 1;
5025       vcc_list = TREE_CHAIN (vcc_list);
5026     }
5027   return 0;
5028 }
5029
5030 /* Check modifiers that can be declared but exclusively */
5031
5032 static void
5033 check_modifiers_consistency (int flags)
5034 {
5035   int acc_count = 0;
5036   tree cl = NULL_TREE;
5037
5038   THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, PUBLIC_TK, acc_count, cl);
5039   THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, PRIVATE_TK, acc_count, cl);
5040   THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, PROTECTED_TK, acc_count, cl);
5041   if (acc_count > 1)
5042     parse_error_context
5043       (cl, "Inconsistent member declaration.  At most one of %<public%>, %<private%>, or %<protected%> may be specified");
5044
5045   acc_count = 0;
5046   cl = NULL_TREE;
5047   THIS_MODIFIER_ONLY (flags, ACC_FINAL, FINAL_TK, acc_count, cl);
5048   THIS_MODIFIER_ONLY (flags, ACC_VOLATILE, VOLATILE_TK, acc_count, cl);
5049   if (acc_count > 1)
5050     parse_error_context (cl,
5051                          "Inconsistent member declaration.  At most one of %<final%> or %<volatile%> may be specified");
5052 }
5053
5054 /* Check the methode header METH for abstract specifics features */
5055
5056 static void
5057 check_abstract_method_header (tree meth)
5058 {
5059   int flags = get_access_flags_from_decl (meth);
5060
5061   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (ABSTRACT_TK), flags,
5062                               ACC_ABSTRACT, "abstract method",
5063                               IDENTIFIER_POINTER (DECL_NAME (meth)));
5064   OBSOLETE_MODIFIER_WARNING2 (MODIFIER_WFL (PUBLIC_TK), flags,
5065                               ACC_PUBLIC, "abstract method",
5066                               IDENTIFIER_POINTER (DECL_NAME (meth)));
5067
5068   check_modifiers ("Illegal modifier %qs for interface method",
5069                   flags, INTERFACE_METHOD_MODIFIERS);
5070 }
5071
5072 /* Create a FUNCTION_TYPE node and start augmenting it with the
5073    declared function arguments. Arguments type that can't be resolved
5074    are left as they are, but the returned node is marked as containing
5075    incomplete types.  */
5076
5077 static tree
5078 method_declarator (tree id, tree list)
5079 {
5080   tree arg_types = NULL_TREE, current, node;
5081   tree meth = make_node (FUNCTION_TYPE);
5082   jdep *jdep;
5083
5084   patch_stage = JDEP_NO_PATCH;
5085
5086   if (GET_CPC () == error_mark_node)
5087     return error_mark_node;
5088
5089   /* If we're dealing with an inner class constructor, we hide the
5090      this$<n> decl in the name field of its parameter declaration.  We
5091      also might have to hide the outer context local alias
5092      initializers. Not done when the class is a toplevel class. */
5093   if (PURE_INNER_CLASS_DECL_P (GET_CPC ())
5094       && EXPR_WFL_NODE (id) == GET_CPC_UN ())
5095     {
5096       tree aliases_list, type, thisn;
5097       /* First the aliases, linked to the regular parameters */
5098       aliases_list =
5099         build_alias_initializer_parameter_list (AIPL_FUNCTION_DECLARATION,
5100                                                 TREE_TYPE (GET_CPC ()),
5101                                                 NULL_TREE, NULL);
5102       list = chainon (nreverse (aliases_list), list);
5103
5104       /* Then this$<n> */
5105       type = TREE_TYPE (DECL_CONTEXT (GET_CPC ()));
5106       thisn = build_current_thisn (TREE_TYPE (GET_CPC ()));
5107       list = tree_cons (build_wfl_node (thisn), build_pointer_type (type),
5108                         list);
5109     }
5110
5111   for (current = list; current; current = TREE_CHAIN (current))
5112     {
5113       int must_chain = 0;
5114       tree wfl_name = TREE_PURPOSE (current);
5115       tree type = TREE_VALUE (current);
5116       tree name = EXPR_WFL_NODE (wfl_name);
5117       tree already, arg_node;
5118       tree type_wfl = NULL_TREE;
5119       tree real_type;
5120
5121       /* Obtain a suitable type for resolution, if necessary */
5122       SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
5123
5124       /* Process NAME, as it may specify extra dimension(s) for it */
5125       type = build_array_from_name (type, type_wfl, name, &name);
5126       EXPR_WFL_NODE (wfl_name) = name;
5127
5128       real_type = GET_REAL_TYPE (type);
5129       if (TREE_CODE (real_type) == RECORD_TYPE)
5130         {
5131           real_type = promote_type (real_type);
5132           if (TREE_CODE (type) == TREE_LIST)
5133             TREE_PURPOSE (type) = real_type;
5134         }
5135
5136       /* Check redefinition */
5137       for (already = arg_types; already; already = TREE_CHAIN (already))
5138         if (TREE_PURPOSE (already) == name)
5139           {
5140             parse_error_context
5141               (wfl_name, "Variable %qs is used more than once in the argument list of method %qs",
5142                IDENTIFIER_POINTER (name),
5143                IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
5144             break;
5145           }
5146
5147       /* If we've an incomplete argument type, we know there is a location
5148          to patch when the type get resolved, later.  */
5149       jdep = NULL;
5150       if (must_chain)
5151         {
5152           patch_stage = JDEP_METHOD;
5153           type = register_incomplete_type (patch_stage,
5154                                            type_wfl, wfl_name, type);
5155           jdep = CLASSD_LAST (ctxp->classd_list);
5156           JDEP_MISC (jdep) = id;
5157         }
5158
5159       /* The argument node: a name and a (possibly) incomplete type.  */
5160       arg_node = build_tree_list (name, real_type);
5161       /* Remember arguments declared final. */
5162       ARG_FINAL_P (arg_node) = ARG_FINAL_P (current);
5163
5164       if (jdep)
5165         JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
5166       TREE_CHAIN (arg_node) = arg_types;
5167       arg_types = arg_node;
5168     }
5169   TYPE_ARG_TYPES (meth) = chainon (nreverse (arg_types), end_params_node);
5170   node = build_tree_list (id, meth);
5171   return node;
5172 }
5173
5174 static int
5175 unresolved_type_p (tree wfl, tree *returned)
5176 {
5177   if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
5178     {
5179       if (returned)
5180         {
5181           tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
5182           if (decl && current_class && (decl == TYPE_NAME (current_class)))
5183             *returned = TREE_TYPE (decl);
5184           else if (GET_CPC_UN () == EXPR_WFL_NODE (wfl))
5185             *returned = TREE_TYPE (GET_CPC ());
5186           else
5187             *returned = NULL_TREE;
5188         }
5189       return 1;
5190     }
5191   if (returned)
5192     *returned = wfl;
5193   return 0;
5194 }
5195
5196 /* From NAME, build a qualified identifier node using the
5197    qualification from the current package definition. */
5198
5199 static tree
5200 parser_qualified_classname (tree name)
5201 {
5202   tree nested_class_name;
5203
5204   if ((nested_class_name = maybe_make_nested_class_name (name)))
5205     return nested_class_name;
5206
5207   if (ctxp->package)
5208     return merge_qualified_name (ctxp->package, name);
5209   else
5210     return name;
5211 }
5212
5213 /* Called once the type a interface extends is resolved. Returns 0 if
5214    everything is OK.  */
5215
5216 static int
5217 parser_check_super_interface (tree super_decl, tree this_decl, tree this_wfl)
5218 {
5219   tree super_type = TREE_TYPE (super_decl);
5220
5221   /* Has to be an interface */
5222   if (!CLASS_INTERFACE (super_decl))
5223     {
5224       parse_error_context
5225         (this_wfl, "%s %qs can't implement/extend %s %qs",
5226          (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
5227           "Interface" : "Class"),
5228          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5229          (TYPE_ARRAY_P (super_type) ? "array" : "class"),
5230          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5231       return 1;
5232     }
5233
5234   /* Check top-level interface access. Inner classes are subject to member
5235      access rules (6.6.1). */
5236   if (! INNER_CLASS_P (super_type)
5237       && check_pkg_class_access (DECL_NAME (super_decl),
5238                                  NULL_TREE, true, this_decl))
5239     return 1;
5240
5241   SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
5242                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5243                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5244   return 0;
5245 }
5246
5247 /* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
5248    0 if everything is OK.  */
5249
5250 static int
5251 parser_check_super (tree super_decl, tree this_decl, tree wfl)
5252 {
5253   tree super_type = TREE_TYPE (super_decl);
5254
5255   /* SUPER should be a CLASS (neither an array nor an interface) */
5256   if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
5257     {
5258       parse_error_context
5259         (wfl, "Class %qs can't subclass %s %qs",
5260          IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5261          (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
5262          IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5263       return 1;
5264     }
5265
5266   if (CLASS_FINAL (TYPE_NAME (super_type)))
5267     {
5268       parse_error_context (wfl, "Can't subclass final classes: %s",
5269                            IDENTIFIER_POINTER (DECL_NAME (super_decl)));
5270       return 1;
5271     }
5272
5273   /* Check top-level class scope. Inner classes are subject to member access
5274      rules (6.6.1). */
5275   if (! INNER_CLASS_P (super_type)
5276       && (check_pkg_class_access (DECL_NAME (super_decl), wfl, true, NULL_TREE)))
5277     return 1;
5278
5279   SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
5280                           IDENTIFIER_POINTER (DECL_NAME (this_decl)),
5281                           IDENTIFIER_POINTER (DECL_NAME (super_decl))));
5282   return 0;
5283 }
5284
5285 /* Create a new dependency list and link it (in a LIFO manner) to the
5286    CTXP list of type dependency list.  */
5287
5288 static void
5289 create_jdep_list (struct parser_ctxt *ctxp)
5290 {
5291   jdeplist *new = xmalloc (sizeof (jdeplist));
5292   new->first = new->last = NULL;
5293   new->next = ctxp->classd_list;
5294   ctxp->classd_list = new;
5295 }
5296
5297 static jdeplist *
5298 reverse_jdep_list (struct parser_ctxt *ctxp)
5299 {
5300   jdeplist *prev = NULL, *current, *next;
5301   for (current = ctxp->classd_list; current; current = next)
5302     {
5303       next = current->next;
5304       current->next = prev;
5305       prev = current;
5306     }
5307   return prev;
5308 }
5309
5310 /* Create a fake pointer based on the ID stored in
5311    TYPE_NAME. TYPE_NAME can be a WFL or a incomplete type asking to be
5312    registered again. */
5313
5314 static tree
5315 obtain_incomplete_type (tree type_name)
5316 {
5317   tree ptr = NULL_TREE, name;
5318
5319   if (TREE_CODE (type_name) == EXPR_WITH_FILE_LOCATION)
5320     name = EXPR_WFL_NODE (type_name);
5321   else if (INCOMPLETE_TYPE_P (type_name))
5322     name = TYPE_NAME (type_name);
5323   else
5324     abort ();
5325
5326   /* Workaround from build_pointer_type for incomplete types.  */
5327   BUILD_PTR_FROM_NAME (ptr, name);
5328   TYPE_MODE (ptr) = ptr_mode;
5329   layout_type (ptr);
5330
5331   return ptr;
5332 }
5333
5334 /* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
5335    non NULL instead of computing a new fake type based on WFL. The new
5336    dependency is inserted in the current type dependency list, in FIFO
5337    manner.  */
5338
5339 static tree
5340 register_incomplete_type (int kind, tree wfl, tree decl, tree ptr)
5341 {
5342   jdep *new = xmalloc (sizeof (jdep));
5343
5344   if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
5345     ptr = obtain_incomplete_type (wfl);
5346
5347   JDEP_KIND (new) = kind;
5348   JDEP_DECL (new) = decl;
5349   JDEP_TO_RESOLVE (new) = ptr;
5350   JDEP_WFL (new) = wfl;
5351   JDEP_CHAIN (new) = NULL;
5352   JDEP_MISC (new) = NULL_TREE;
5353   /* For some dependencies, set the enclosing class of the current
5354      class to be the enclosing context */
5355   if ((kind == JDEP_INTERFACE || kind == JDEP_ANONYMOUS || kind == JDEP_SUPER)
5356       && GET_ENCLOSING_CPC ())
5357     JDEP_ENCLOSING (new) = TREE_VALUE (GET_ENCLOSING_CPC ());
5358   else
5359     JDEP_ENCLOSING (new) = GET_CPC ();
5360   JDEP_GET_PATCH (new) = (tree *)NULL;
5361
5362   JDEP_INSERT (ctxp->classd_list, new);
5363
5364   return ptr;
5365 }
5366
5367 /* This checks for circular references with innerclasses. We start
5368    from SOURCE and should never reach TARGET. Extended/implemented
5369    types in SOURCE have their enclosing context checked not to reach
5370    TARGET. When the last enclosing context of SOURCE is reached, its
5371    extended/implemented types are also checked not to reach TARGET.
5372    In case of error, WFL of the offending type is returned; NULL_TREE
5373    otherwise.  */
5374
5375 static tree
5376 check_inner_circular_reference (tree source, tree target)
5377 {
5378   tree base_binfo;
5379   tree ctx, cl;
5380   int i;
5381
5382   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (source), i, base_binfo); i++)
5383     {
5384       tree su;
5385
5386       /* We can end up with a NULL_TREE or an incomplete type here if
5387          we encountered previous type resolution errors. It's safe to
5388          simply ignore these cases.  */
5389       su = BINFO_TYPE (base_binfo);
5390       if (INCOMPLETE_TYPE_P (su))
5391         continue;
5392
5393       if (inherits_from_p (su, target))
5394         return lookup_cl (TYPE_NAME (su));
5395
5396       for (ctx = DECL_CONTEXT (TYPE_NAME (su)); ctx; ctx = DECL_CONTEXT (ctx))
5397         {
5398           /* An enclosing context shouldn't be TARGET */
5399           if (ctx == TYPE_NAME (target))
5400             return lookup_cl (TYPE_NAME (su));
5401
5402           /* When we reach the enclosing last context, start a check
5403              on it, with the same target */
5404           if (! DECL_CONTEXT (ctx) &&
5405               (cl = check_inner_circular_reference (TREE_TYPE (ctx), target)))
5406             return cl;
5407         }
5408     }
5409   return NULL_TREE;
5410 }
5411
5412 /* Explore TYPE's `extends' clause member(s) and return the WFL of the
5413    offending type if a circularity is detected. NULL_TREE is returned
5414    otherwise. TYPE can be an interface or a class.   */
5415
5416 static tree
5417 check_circular_reference (tree type)
5418 {
5419   tree base_binfo;
5420   int i;
5421
5422   if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type)))
5423     return NULL_TREE;
5424
5425   if (! CLASS_INTERFACE (TYPE_NAME (type)))
5426     {
5427       if (inherits_from_p (CLASSTYPE_SUPER (type), type))
5428         return lookup_cl (TYPE_NAME (type));
5429       return NULL_TREE;
5430     }
5431
5432   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (type), i, base_binfo); i++)
5433     {
5434       if (BINFO_TYPE (base_binfo) != object_type_node
5435           && interface_of_p (type, BINFO_TYPE (base_binfo)))
5436         return lookup_cl (TYPE_NAME (BINFO_TYPE (base_binfo)));
5437     }
5438   return NULL_TREE;
5439 }
5440
5441 void
5442 java_check_circular_reference (void)
5443 {
5444   tree current;
5445   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5446     {
5447       tree type = TREE_TYPE (current);
5448       tree cl;
5449
5450       cl = check_circular_reference (type);
5451       if (! cl)
5452         cl = check_inner_circular_reference (type, type);
5453       if (cl)
5454         parse_error_context (cl, "Cyclic class inheritance%s",
5455                              (cyclic_inheritance_report ?
5456                               cyclic_inheritance_report : ""));
5457     }
5458 }
5459
5460 /* Augment the parameter list PARM with parameters crafted to
5461    initialize outer context locals aliases. Through ARTIFICIAL, a
5462    count is kept of the number of crafted parameters. MODE governs
5463    what eventually gets created: something suitable for a function
5464    creation or a function invocation, either the constructor or
5465    finit$.  */
5466
5467 static tree
5468 build_alias_initializer_parameter_list (int mode, tree class_type, tree parm,
5469                                         int *artificial)
5470 {
5471   tree field;
5472   tree additional_parms = NULL_TREE;
5473
5474   for (field = TYPE_FIELDS (class_type); field; field = TREE_CHAIN (field))
5475     if (FIELD_LOCAL_ALIAS (field))
5476       {
5477         const char *buffer = IDENTIFIER_POINTER (DECL_NAME (field));
5478         tree purpose = NULL_TREE, value = NULL_TREE, name = NULL_TREE;
5479         tree mangled_id;
5480
5481         switch (mode)
5482           {
5483           case AIPL_FUNCTION_DECLARATION:
5484             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5485                                                          &buffer [4]);
5486             purpose = build_wfl_node (mangled_id);
5487             if (TREE_CODE (TREE_TYPE (field)) == POINTER_TYPE)
5488               value = build_wfl_node (TYPE_NAME (TREE_TYPE (field)));
5489             else
5490               value = TREE_TYPE (field);
5491             break;
5492
5493           case AIPL_FUNCTION_CREATION:
5494             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (purpose,
5495                                                          &buffer [4]);
5496             value = TREE_TYPE (field);
5497             break;
5498
5499           case AIPL_FUNCTION_FINIT_INVOCATION:
5500             MANGLE_ALIAS_INITIALIZER_PARAMETER_NAME_STR (mangled_id,
5501                                                          &buffer [4]);
5502             /* Now, this is wrong. purpose should always be the NAME
5503                of something and value its matching value (decl, type,
5504                etc...) FIXME -- but there is a lot to fix. */
5505
5506             /* When invoked for this kind of operation, we already
5507                know whether a field is used or not. */
5508             purpose = TREE_TYPE (field);
5509             value = build_wfl_node (mangled_id);
5510             break;
5511
5512           case AIPL_FUNCTION_CTOR_INVOCATION:
5513             /* There are two case: the constructor invocation happens
5514                outside the local inner, in which case, locales from the outer
5515                context are directly used.
5516
5517                Otherwise, we fold to using the alias directly. */
5518             if (class_type == current_class)
5519               value = field;
5520             else
5521               {
5522                 name = get_identifier (&buffer[4]);
5523                 value = IDENTIFIER_LOCAL_VALUE (name);
5524               }
5525             break;
5526           }
5527         additional_parms = tree_cons (purpose, value, additional_parms);
5528         if (artificial)
5529           *artificial +=1;
5530       }
5531   if (additional_parms)
5532     {
5533       if (ANONYMOUS_CLASS_P (class_type)
5534           && mode == AIPL_FUNCTION_CTOR_INVOCATION)
5535         additional_parms = nreverse (additional_parms);
5536       parm = chainon (additional_parms, parm);
5537     }
5538
5539    return parm;
5540 }
5541
5542 /* Craft a constructor for CLASS_DECL -- what we should do when none
5543    where found. ARGS is non NULL when a special signature must be
5544    enforced. This is the case for anonymous classes.  */
5545
5546 static tree
5547 craft_constructor (tree class_decl, tree args)
5548 {
5549   tree class_type = TREE_TYPE (class_decl);
5550   tree parm = NULL_TREE;
5551   /* Inherit access flags for the constructor from its enclosing class. */
5552   int valid_ctor_flags = ACC_PUBLIC | ACC_PROTECTED | ACC_PRIVATE;
5553   int flags = (get_access_flags_from_decl (class_decl) & valid_ctor_flags);
5554   int i = 0, artificial = 0;
5555   tree decl, ctor_name;
5556   char buffer [80];
5557
5558   ctor_name = init_identifier_node;
5559
5560   /* If we're dealing with an inner class constructor, we hide the
5561      this$<n> decl in the name field of its parameter declaration. */
5562   if (PURE_INNER_CLASS_TYPE_P (class_type))
5563     {
5564       tree type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_type)));
5565       parm = tree_cons (build_current_thisn (class_type),
5566                         build_pointer_type (type), parm);
5567
5568       /* Some more arguments to be hidden here. The values of the local
5569          variables of the outer context that the inner class needs to see. */
5570       parm = build_alias_initializer_parameter_list (AIPL_FUNCTION_CREATION,
5571                                                      class_type, parm,
5572                                                      &artificial);
5573     }
5574
5575   /* Then if there are any args to be enforced, enforce them now */
5576   for (; args && args != end_params_node; args = TREE_CHAIN (args))
5577     {
5578       /* If we see a `void *', we need to change it to Object.  */
5579       if (TREE_VALUE (args) == TREE_TYPE (null_pointer_node))
5580         TREE_VALUE (args) = object_ptr_type_node;
5581
5582       sprintf (buffer, "parm%d", i++);
5583       parm = tree_cons (get_identifier (buffer), TREE_VALUE (args), parm);
5584     }
5585
5586   CRAFTED_PARAM_LIST_FIXUP (parm);
5587   decl = create_artificial_method (class_type, flags, void_type_node,
5588                                    ctor_name, parm);
5589   fix_method_argument_names (parm, decl);
5590   /* Now, mark the artificial parameters. */
5591   DECL_FUNCTION_NAP (decl) = artificial;
5592   DECL_FUNCTION_SYNTHETIC_CTOR (decl) = DECL_CONSTRUCTOR_P (decl) = 1;
5593   DECL_INLINE (decl) = 1;
5594   return decl;
5595 }
5596
5597
5598 /* Fix the constructors. This will be called right after circular
5599    references have been checked. It is necessary to fix constructors
5600    early even if no code generation will take place for that class:
5601    some generated constructor might be required by the class whose
5602    compilation triggered this one to be simply loaded.  */
5603
5604 void
5605 java_fix_constructors (void)
5606 {
5607   tree current;
5608
5609   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
5610     {
5611       tree class_type = TREE_TYPE (current);
5612       int saw_ctor = 0;
5613       tree decl;
5614
5615       if (CLASS_INTERFACE (TYPE_NAME (class_type)))
5616         continue;
5617
5618       output_class = current_class = class_type;
5619       for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
5620         {
5621           if (DECL_CONSTRUCTOR_P (decl))
5622             {
5623               fix_constructors (decl);
5624               saw_ctor = 1;
5625             }
5626         }
5627
5628       /* Anonymous class constructor can't be generated that early. */
5629       if (!saw_ctor && !ANONYMOUS_CLASS_P (class_type))
5630         craft_constructor (current, NULL_TREE);
5631     }
5632 }
5633
5634 /* safe_layout_class just makes sure that we can load a class without
5635    disrupting the current_class, input_file, input_line, etc, information
5636    about the class processed currently.  */
5637
5638 void
5639 safe_layout_class (tree class)
5640 {
5641   tree save_current_class = current_class;
5642   location_t save_location = input_location;
5643
5644   layout_class (class);
5645
5646   current_class = save_current_class;
5647   input_location = save_location;
5648 }
5649
5650 static tree
5651 jdep_resolve_class (jdep *dep)
5652 {
5653   tree decl;
5654
5655   /* Set the correct context for class resolution.  */
5656   current_class = TREE_TYPE (JDEP_ENCLOSING (dep));
5657
5658   if (JDEP_RESOLVED_P (dep))
5659     decl = JDEP_RESOLVED_DECL (dep);
5660   else
5661     {
5662       decl = resolve_class (JDEP_ENCLOSING (dep), JDEP_TO_RESOLVE (dep),
5663                             JDEP_DECL (dep), JDEP_WFL (dep));
5664       JDEP_RESOLVED (dep, decl);
5665       /* If there is no WFL, that's ok.  We generate this warning
5666          elsewhere.  */
5667       if (decl && JDEP_WFL (dep) != NULL_TREE)
5668         check_deprecation (JDEP_WFL (dep), decl);
5669     }
5670
5671   if (!decl)
5672     complete_class_report_errors (dep);
5673   else if (INNER_CLASS_DECL_P (decl))
5674     {
5675       tree inner = TREE_TYPE (decl);
5676       if (! CLASS_LOADED_P (inner))
5677         {
5678           safe_layout_class (inner);
5679           if (TYPE_SIZE (inner) == error_mark_node)
5680             TYPE_SIZE (inner) = NULL_TREE;
5681         }
5682       check_inner_class_access (decl, JDEP_ENCLOSING (dep), JDEP_WFL (dep));
5683     }
5684   return decl;
5685 }
5686
5687 /* Complete unsatisfied class declaration and their dependencies */
5688
5689 void
5690 java_complete_class (void)
5691 {
5692   tree cclass;
5693   jdeplist *cclassd;
5694   int error_found;
5695   tree type;
5696
5697   /* Process imports */
5698   process_imports ();
5699
5700   /* Reverse things so we have the right order */
5701   ctxp->class_list = nreverse (ctxp->class_list);
5702   ctxp->classd_list = reverse_jdep_list (ctxp);
5703
5704   for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
5705        cclass && cclassd;
5706        cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
5707     {
5708       jdep *dep;
5709
5710       for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
5711         {
5712           tree decl;
5713           if (!(decl = jdep_resolve_class (dep)))
5714             continue;
5715
5716           /* Now it's time to patch */
5717           switch (JDEP_KIND (dep))
5718             {
5719             case JDEP_SUPER:
5720               /* Simply patch super */
5721               if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
5722                 continue;
5723               BINFO_TYPE (BINFO_BASE_BINFO
5724                           (TYPE_BINFO (TREE_TYPE (JDEP_DECL (dep))), 0))
5725                 = TREE_TYPE (decl);
5726               break;
5727
5728             case JDEP_FIELD:
5729               {
5730                 /* We do part of the job done in add_field */
5731                 tree field_decl = JDEP_DECL (dep);
5732                 tree field_type = TREE_TYPE (decl);
5733                 if (TREE_CODE (field_type) == RECORD_TYPE)
5734                   field_type = promote_type (field_type);
5735                 TREE_TYPE (field_decl) = field_type;
5736                 DECL_ALIGN (field_decl) = 0;
5737                 DECL_USER_ALIGN (field_decl) = 0;
5738                 layout_decl (field_decl, 0);
5739                 SOURCE_FRONTEND_DEBUG
5740                   (("Completed field/var decl '%s' with '%s'",
5741                     IDENTIFIER_POINTER (DECL_NAME (field_decl)),
5742                     IDENTIFIER_POINTER (DECL_NAME (decl))));
5743                 break;
5744               }
5745             case JDEP_METHOD:   /* We start patching a method */
5746             case JDEP_METHOD_RETURN:
5747               error_found = 0;
5748               while (1)
5749                 {
5750                   if (decl)
5751                     {
5752                       type = TREE_TYPE(decl);
5753                       if (TREE_CODE (type) == RECORD_TYPE)
5754                         type = promote_type (type);
5755                       JDEP_APPLY_PATCH (dep, type);
5756                       SOURCE_FRONTEND_DEBUG
5757                         (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
5758                            "Completing fct '%s' with ret type '%s'":
5759                            "Completing arg '%s' with type '%s'"),
5760                           IDENTIFIER_POINTER (EXPR_WFL_NODE
5761                                               (JDEP_DECL_WFL (dep))),
5762                           IDENTIFIER_POINTER (DECL_NAME (decl))));
5763                     }
5764                   else
5765                     error_found = 1;
5766                   dep = JDEP_CHAIN (dep);
5767                   if (JDEP_KIND (dep) == JDEP_METHOD_END)
5768                     break;
5769                   else
5770                     decl = jdep_resolve_class (dep);
5771                 }
5772               if (!error_found)
5773                 {
5774                   tree mdecl = JDEP_DECL (dep), signature;
5775                   /* Recompute and reset the signature, check first that
5776                      all types are now defined. If they're not,
5777                      don't build the signature. */
5778                   if (check_method_types_complete (mdecl))
5779                     {
5780                       signature = build_java_signature (TREE_TYPE (mdecl));
5781                       set_java_signature (TREE_TYPE (mdecl), signature);
5782                     }
5783                 }
5784               else
5785                 continue;
5786               break;
5787
5788             case JDEP_INTERFACE:
5789               if (parser_check_super_interface (decl, JDEP_DECL (dep),
5790                                                 JDEP_WFL (dep)))
5791                 continue;
5792               parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
5793               break;
5794
5795             case JDEP_PARM:
5796             case JDEP_VARIABLE:
5797               type = TREE_TYPE(decl);
5798               if (TREE_CODE (type) == RECORD_TYPE)
5799                 type = promote_type (type);
5800               JDEP_APPLY_PATCH (dep, type);
5801               break;
5802
5803             case JDEP_TYPE:
5804               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5805               SOURCE_FRONTEND_DEBUG
5806                 (("Completing a random type dependency on a '%s' node",
5807                   tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
5808               break;
5809
5810             case JDEP_EXCEPTION:
5811               JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
5812               SOURCE_FRONTEND_DEBUG
5813                 (("Completing '%s' 'throws' argument node",
5814                   IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))));
5815               break;
5816
5817             case JDEP_ANONYMOUS:
5818               patch_anonymous_class (decl, JDEP_DECL (dep), JDEP_WFL (dep));
5819               break;
5820
5821             default:
5822               abort ();
5823             }
5824         }
5825     }
5826   return;
5827 }
5828
5829 /* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
5830    array.  */
5831
5832 static tree
5833 resolve_class (tree enclosing, tree class_type, tree decl, tree cl)
5834 {
5835   tree tname = TYPE_NAME (class_type);
5836   tree resolved_type = TREE_TYPE (class_type);
5837   int array_dims = 0;
5838   tree resolved_type_decl;
5839
5840   if (resolved_type != NULL_TREE)
5841     {
5842       tree resolved_type_decl = TYPE_NAME (resolved_type);
5843       if (resolved_type_decl == NULL_TREE
5844           || TREE_CODE (resolved_type_decl) == IDENTIFIER_NODE)
5845         {
5846           resolved_type_decl = build_decl (TYPE_DECL,
5847                                            TYPE_NAME (class_type),
5848                                            resolved_type);
5849         }
5850       return resolved_type_decl;
5851     }
5852
5853   /* 1- Check to see if we have an array. If true, find what we really
5854      want to resolve  */
5855   if ((array_dims = build_type_name_from_array_name (tname,
5856                                                      &TYPE_NAME (class_type))))
5857     WFL_STRIP_BRACKET (cl, cl);
5858
5859   /* 2- Resolve the bare type */
5860   if (!(resolved_type_decl = do_resolve_class (enclosing, NULL_TREE, class_type,
5861                                                decl, cl)))
5862     return NULL_TREE;
5863   resolved_type = TREE_TYPE (resolved_type_decl);
5864
5865   /* 3- If we have an array, reconstruct the array down to its nesting */
5866   if (array_dims)
5867     {
5868       for (; array_dims; array_dims--)
5869         resolved_type = build_java_array_type (resolved_type, -1);
5870       resolved_type_decl = TYPE_NAME (resolved_type);
5871     }
5872   TREE_TYPE (class_type) = resolved_type;
5873   return resolved_type_decl;
5874 }
5875
5876 /* Effectively perform the resolution of class CLASS_TYPE.  DECL or CL
5877    are used to report error messages; CL must either be NULL_TREE or a
5878    WFL wrapping a class.  Do not try to replace TYPE_NAME (class_type)
5879    by a variable, since it is changed by find_in_imports{_on_demand}
5880    and (but it doesn't really matter) qualify_and_find.  */
5881
5882 tree
5883 do_resolve_class (tree enclosing, tree import_type, tree class_type, tree decl,
5884                   tree cl)
5885 {
5886   tree new_class_decl = NULL_TREE;
5887   tree saved_enclosing_type = enclosing ? TREE_TYPE (enclosing) : NULL_TREE;
5888   tree candidate = NULL_TREE;
5889   tree decl_result;
5890
5891   if (QUALIFIED_P (TYPE_NAME (class_type)))
5892     {
5893       /* If the type name is of the form `Q . Id', then Q is either a
5894          package name or a class name.  First we try to find Q as a
5895          class and then treat Id as a member type.  If we can't find Q
5896          as a class then we fall through.  */
5897       tree q, left, left_type, right;
5898       if (split_qualified_name (&left, &right, TYPE_NAME (class_type)) == 0)
5899         {
5900           BUILD_PTR_FROM_NAME (left_type, left);
5901           q = do_resolve_class (enclosing, import_type, left_type, decl, cl);
5902           if (q)
5903             {
5904               enclosing = q;
5905               saved_enclosing_type = TREE_TYPE (q);
5906               BUILD_PTR_FROM_NAME (class_type, right);
5907             }
5908         }
5909     }
5910
5911   if (enclosing)
5912     {
5913       tree context = enclosing;
5914
5915       /* 0- Search in the current class as an inner class.
5916          Maybe some code here should be added to load the class or
5917          something, at least if the class isn't an inner class and ended
5918          being loaded from class file. FIXME. */
5919       while (enclosing)
5920         {
5921           new_class_decl = resolve_inner_class (context, cl, enclosing, class_type);
5922
5923           if (new_class_decl)
5924             {
5925               if (inner_class_accessible (new_class_decl, context))
5926                 break;
5927               else
5928                 if (candidate == NULL_TREE)
5929                   candidate = new_class_decl;
5930                 new_class_decl = NULL_TREE;
5931             }
5932
5933           /* Now that we've looked through all superclasses, try the enclosing
5934              context. */
5935           enclosing = DECL_CONTEXT (enclosing);
5936         }
5937
5938       if (new_class_decl)
5939         return new_class_decl;
5940     }
5941
5942   /* 1- Check for the type in single imports.  Look at enclosing classes and,
5943      if we're laying out a superclass, at the import list for the subclass.
5944      This will change TYPE_NAME() if something relevant is found. */
5945   if (import_type && TYPE_IMPORT_LIST (import_type))
5946     find_in_imports (import_type, class_type);
5947   find_in_imports (saved_enclosing_type, class_type);
5948
5949   /* 2- And check for the type in the current compilation unit */
5950   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5951     {
5952       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
5953         load_class (TYPE_NAME (class_type), 0);
5954       return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5955     }
5956
5957   /* 3- Search according to the current package definition */
5958   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5959     {
5960       if ((new_class_decl = qualify_and_find (class_type,
5961                 TYPE_PACKAGE (current_class), TYPE_NAME (class_type))))
5962         return new_class_decl;
5963     }
5964
5965   /* 4- Check the import on demands. Don't allow bar.baz to be
5966      imported from foo.* */
5967   if (!QUALIFIED_P (TYPE_NAME (class_type)))
5968     {
5969       if (import_type
5970           && TYPE_IMPORT_DEMAND_LIST (import_type)
5971           && find_in_imports_on_demand (import_type, class_type))
5972         return NULL_TREE;
5973       if (find_in_imports_on_demand (saved_enclosing_type, class_type))
5974         return NULL_TREE;
5975     }
5976
5977   /* If found in find_in_imports_on_demand, the type has already been
5978      loaded. */
5979   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
5980     return new_class_decl;
5981
5982   /* 5- Check another compilation unit that bears the name of type */
5983   load_class (TYPE_NAME (class_type), 0);
5984
5985   if (!cl)
5986     cl = lookup_cl (decl);
5987
5988   /* If we don't have a value for CL, then we're being called recursively.
5989      We can't check package access just yet, but it will be taken care of
5990      by the caller. */
5991   if (cl)
5992     {
5993       if (check_pkg_class_access (TYPE_NAME (class_type), cl, true, NULL_TREE))
5994         return NULL_TREE;
5995     }
5996
5997   /* 6- Last call for a resolution */
5998   decl_result = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
5999
6000   /* The final lookup might have registered a.b.c into a.b$c If we
6001      failed at the first lookup, progressively change the name if
6002      applicable and use the matching DECL instead. */
6003   if (!decl_result && QUALIFIED_P (TYPE_NAME (class_type)))
6004     {
6005       char *separator;
6006       tree name = TYPE_NAME (class_type);
6007       char *namebuffer = alloca (IDENTIFIER_LENGTH (name) + 1);
6008
6009       strcpy (namebuffer, IDENTIFIER_POINTER (name));
6010
6011       do {
6012
6013        /* Reach the last '.', and if applicable, replace it by a `$' and
6014           see if this exists as a type. */
6015        if ((separator = strrchr (namebuffer, '.')))
6016          {
6017            *separator = '$';
6018            name = get_identifier (namebuffer);
6019            decl_result = IDENTIFIER_CLASS_VALUE (name);
6020          }
6021       } while (!decl_result && separator);
6022     }
6023   if (decl_result)
6024     return decl_result;
6025   else
6026     return candidate;
6027 }
6028
6029 static tree
6030 qualify_and_find (tree class_type, tree package, tree name)
6031 {
6032   tree new_qualified = merge_qualified_name (package, name);
6033   tree new_class_decl;
6034
6035   if (!IDENTIFIER_CLASS_VALUE (new_qualified))
6036     load_class (new_qualified, 0);
6037   if ((new_class_decl = IDENTIFIER_CLASS_VALUE (new_qualified)))
6038     {
6039       if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)))
6040         load_class (TREE_TYPE (new_class_decl), 0);
6041       TYPE_NAME (class_type) = new_qualified;
6042       return IDENTIFIER_CLASS_VALUE (new_qualified);
6043     }
6044   return NULL_TREE;
6045 }
6046
6047 /* Resolve NAME and lay it out (if not done and if not the current
6048    parsed class). Return a decl node. This function is meant to be
6049    called when type resolution is necessary during the walk pass.  */
6050
6051 static tree
6052 resolve_and_layout (tree something, tree cl)
6053 {
6054   tree decl, decl_type;
6055
6056   /* Don't do that on the current class */
6057   if (something == current_class)
6058     return TYPE_NAME (current_class);
6059
6060   /* Don't do anything for void and other primitive types */
6061   if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
6062     return NULL_TREE;
6063
6064   /* Pointer types can be reall pointer types or fake pointers. When
6065      finding a real pointer, recheck for primitive types */
6066   if (TREE_CODE (something) == POINTER_TYPE)
6067     {
6068       if (TREE_TYPE (something))
6069         {
6070           something = TREE_TYPE (something);
6071           if (JPRIMITIVE_TYPE_P (something) || something == void_type_node)
6072             return NULL_TREE;
6073         }
6074       else
6075         something = TYPE_NAME (something);
6076     }
6077
6078   /* Don't do anything for arrays of primitive types */
6079   if (TREE_CODE (something) == RECORD_TYPE && TYPE_ARRAY_P (something)
6080       && JPRIMITIVE_TYPE_P (TYPE_ARRAY_ELEMENT (something)))
6081     return NULL_TREE;
6082
6083   /* Something might be a WFL */
6084   if (TREE_CODE (something) == EXPR_WITH_FILE_LOCATION)
6085     something = EXPR_WFL_NODE (something);
6086
6087   /* Otherwise, if something is not and IDENTIFIER_NODE, it can be a
6088      TYPE_DECL or a real TYPE.  */
6089   else if (TREE_CODE (something) != IDENTIFIER_NODE)
6090     something = (TREE_CODE (TYPE_NAME (something)) == TYPE_DECL ?
6091             DECL_NAME (TYPE_NAME (something)) : TYPE_NAME (something));
6092
6093   if (!(decl = resolve_no_layout (something, cl)))
6094     return NULL_TREE;
6095
6096   /* Resolve and layout if necessary */
6097   decl_type = TREE_TYPE (decl);
6098   layout_class_methods (decl_type);
6099   /* Check methods */
6100   if (CLASS_FROM_SOURCE_P (decl_type))
6101     java_check_methods (decl);
6102   /* Layout the type if necessary */
6103   if (decl_type != current_class && !CLASS_LOADED_P (decl_type))
6104     safe_layout_class (decl_type);
6105
6106   return decl;
6107 }
6108
6109 /* Resolve a class, returns its decl but doesn't perform any
6110    layout. The current parsing context is saved and restored */
6111
6112 static tree
6113 resolve_no_layout (tree name, tree cl)
6114 {
6115   tree ptr, decl;
6116   BUILD_PTR_FROM_NAME (ptr, name);
6117   java_parser_context_save_global ();
6118   decl = resolve_class (TYPE_NAME (current_class), ptr, NULL_TREE, cl);
6119   java_parser_context_restore_global ();
6120
6121   return decl;
6122 }
6123
6124 /* Called when reporting errors. Skip the '[]'s in a complex array
6125    type description that failed to be resolved. purify_type_name can't
6126    use an identifier tree.  */
6127
6128 static const char *
6129 purify_type_name (const char *name)
6130 {
6131   int len = strlen (name);
6132   int bracket_found;
6133
6134   STRING_STRIP_BRACKETS (name, len, bracket_found);
6135   if (bracket_found)
6136     {
6137       char *stripped_name = xmemdup (name, len, len+1);
6138       stripped_name [len] = '\0';
6139       return stripped_name;
6140     }
6141   return name;
6142 }
6143
6144 /* The type CURRENT refers to can't be found. We print error messages.  */
6145
6146 static void
6147 complete_class_report_errors (jdep *dep)
6148 {
6149   const char *name;
6150
6151   if (!JDEP_WFL (dep))
6152     return;
6153
6154   name = IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)));
6155   switch (JDEP_KIND (dep))
6156     {
6157     case JDEP_SUPER:
6158       parse_error_context
6159         (JDEP_WFL (dep), "Superclass %qs of class %qs not found",
6160          purify_type_name (name),
6161          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6162       break;
6163     case JDEP_FIELD:
6164       parse_error_context
6165         (JDEP_WFL (dep), "Type %qs not found in declaration of field %qs",
6166          purify_type_name (name),
6167          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6168       break;
6169     case JDEP_METHOD:           /* Covers arguments */
6170       parse_error_context
6171         (JDEP_WFL (dep), "Type %qs not found in the declaration of the argument %qs of method %qs",
6172          purify_type_name (name),
6173          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
6174          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
6175       break;
6176     case JDEP_METHOD_RETURN:    /* Covers return type */
6177       parse_error_context
6178         (JDEP_WFL (dep), "Type %qs not found in the declaration of the return type of method %qs",
6179          purify_type_name (name),
6180          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
6181       break;
6182     case JDEP_INTERFACE:
6183       parse_error_context
6184         (JDEP_WFL (dep), "Superinterface %qs of %s %qs not found",
6185          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
6186          (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
6187          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6188       break;
6189     case JDEP_VARIABLE:
6190       parse_error_context
6191         (JDEP_WFL (dep), "Type %qs not found in the declaration of the local variable %qs",
6192          purify_type_name (IDENTIFIER_POINTER
6193                            (EXPR_WFL_NODE (JDEP_WFL (dep)))),
6194          IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
6195       break;
6196     case JDEP_EXCEPTION:        /* As specified by `throws' */
6197       parse_error_context
6198           (JDEP_WFL (dep), "Class %qs not found in %<throws%>",
6199          IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))));
6200       break;
6201     default:
6202       /* Fix for -Wall. Just break doing nothing. The error will be
6203          caught later */
6204       break;
6205     }
6206 }
6207
6208 /* Return a static string containing the DECL prototype string. If
6209    DECL is a constructor, use the class name instead of the form
6210    <init> */
6211
6212 static const char *
6213 get_printable_method_name (tree decl)
6214 {
6215   const char *to_return;
6216   tree name = NULL_TREE;
6217
6218   if (DECL_CONSTRUCTOR_P (decl))
6219     {
6220       name = DECL_NAME (decl);
6221       DECL_NAME (decl) = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
6222     }
6223
6224   to_return = lang_printable_name (decl, 2);
6225   if (DECL_CONSTRUCTOR_P (decl))
6226     DECL_NAME (decl) = name;
6227
6228   return to_return;
6229 }
6230
6231 /* Track method being redefined inside the same class. As a side
6232    effect, set DECL_NAME to an IDENTIFIER (prior entering this
6233    function it's a FWL, so we can track errors more accurately.)  */
6234
6235 static int
6236 check_method_redefinition (tree class, tree method)
6237 {
6238   tree redef, sig;
6239
6240   /* There's no need to verify <clinit> and finit$ and instinit$ */
6241   if (DECL_CLINIT_P (method)
6242       || DECL_FINIT_P (method) || DECL_INSTINIT_P (method))
6243     return 0;
6244
6245   sig = TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (method));
6246   for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
6247     {
6248       if (redef == method)
6249         break;
6250       if (DECL_NAME (redef) == DECL_NAME (method)
6251           && sig == TYPE_ARGUMENT_SIGNATURE (TREE_TYPE (redef))
6252           && !DECL_ARTIFICIAL (method))
6253         {
6254           parse_error_context
6255             (DECL_FUNCTION_WFL (method), "Duplicate %s declaration %qs",
6256              (DECL_CONSTRUCTOR_P (redef) ? "constructor" : "method"),
6257              get_printable_method_name (redef));
6258           return 1;
6259         }
6260     }
6261   return 0;
6262 }
6263
6264 /* Return 1 if check went ok, 0 otherwise.  */
6265 static int
6266 check_abstract_method_definitions (int do_interface, tree class_decl,
6267                                    tree type)
6268 {
6269   tree class = TREE_TYPE (class_decl);
6270   tree method, end_type;
6271   int ok = 1;
6272
6273   end_type = (do_interface ? object_type_node : type);
6274   for (method = TYPE_METHODS (type); method; method = TREE_CHAIN (method))
6275     {
6276       tree other_super, other_method, method_sig, method_name;
6277       int found = 0;
6278       int end_type_reached = 0;
6279
6280       if (!METHOD_ABSTRACT (method) || METHOD_FINAL (method))
6281         continue;
6282
6283       /* Now verify that somewhere in between TYPE and CLASS,
6284          abstract method METHOD gets a non abstract definition
6285          that is inherited by CLASS.  */
6286
6287       method_sig = build_java_signature (TREE_TYPE (method));
6288       method_name = DECL_NAME (method);
6289       if (TREE_CODE (method_name) == EXPR_WITH_FILE_LOCATION)
6290         method_name = EXPR_WFL_NODE (method_name);
6291
6292       other_super = class;
6293       do {
6294         if (other_super == end_type)
6295           end_type_reached = 1;
6296
6297         /* Method search */
6298         for (other_method = TYPE_METHODS (other_super); other_method;
6299             other_method = TREE_CHAIN (other_method))
6300           {
6301             tree s = build_java_signature (TREE_TYPE (other_method));
6302             tree other_name = DECL_NAME (other_method);
6303
6304             if (TREE_CODE (other_name) == EXPR_WITH_FILE_LOCATION)
6305               other_name = EXPR_WFL_NODE (other_name);
6306             if (!DECL_CLINIT_P (other_method)
6307                 && !DECL_CONSTRUCTOR_P (other_method)
6308                 && method_name == other_name
6309                 && method_sig == s
6310                 && !METHOD_ABSTRACT (other_method))
6311              {
6312                found = 1;
6313                break;
6314              }
6315           }
6316         other_super = CLASSTYPE_SUPER (other_super);
6317       } while (!end_type_reached);
6318
6319       /* Report that abstract METHOD didn't find an implementation
6320          that CLASS can use. */
6321       if (!found)
6322         {
6323           char *t = xstrdup (lang_printable_name
6324                             (TREE_TYPE (TREE_TYPE (method)), 0));
6325           tree ccn = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
6326
6327           parse_error_context
6328             (lookup_cl (class_decl),
6329              "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",
6330              IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6331              t, lang_printable_name (method, 2),
6332              (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))) ?
6333               "interface" : "class"),
6334              IDENTIFIER_POINTER (ccn),
6335              (CLASS_INTERFACE (class_decl) ? "interface" : "class"),
6336              IDENTIFIER_POINTER (DECL_NAME (class_decl)));
6337           ok = 0;
6338           free (t);
6339         }
6340     }
6341
6342   if (ok && do_interface)
6343     {
6344       /* Check for implemented interfaces. */
6345       int i;
6346       tree base_binfo;
6347
6348       for (i = 1;
6349            ok && BINFO_BASE_ITERATE (TYPE_BINFO (type), i, base_binfo);
6350            i++)
6351         ok = check_abstract_method_definitions (1, class_decl,
6352                                                 BINFO_TYPE (base_binfo));
6353     }
6354
6355   return ok;
6356 }
6357
6358 /* Check that CLASS_DECL somehow implements all inherited abstract
6359    methods.  */
6360
6361 static void
6362 java_check_abstract_method_definitions (tree class_decl)
6363 {
6364   tree class = TREE_TYPE (class_decl);
6365   tree super, base_binfo;
6366   int i;
6367
6368   if (CLASS_ABSTRACT (class_decl))
6369     return;
6370
6371   /* Check for inherited types */
6372   super = class;
6373   do {
6374     super = CLASSTYPE_SUPER (super);
6375     check_abstract_method_definitions (0, class_decl, super);
6376   } while (super != object_type_node);
6377
6378   /* Check for implemented interfaces. */
6379   for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6380     check_abstract_method_definitions (1, class_decl, BINFO_TYPE (base_binfo));
6381 }
6382
6383 /* Check all the types method DECL uses and return 1 if all of them
6384    are now complete, 0 otherwise. This is used to check whether its
6385    safe to build a method signature or not.  */
6386
6387 static int
6388 check_method_types_complete (tree decl)
6389 {
6390   tree type = TREE_TYPE (decl);
6391   tree args;
6392
6393   if (!INCOMPLETE_TYPE_P (TREE_TYPE (type)))
6394     return 0;
6395
6396   args = TYPE_ARG_TYPES (type);
6397   if (TREE_CODE (type) == METHOD_TYPE)
6398     args = TREE_CHAIN (args);
6399   for (; args != end_params_node; args = TREE_CHAIN (args))
6400     if (INCOMPLETE_TYPE_P (TREE_VALUE (args)))
6401       return 0;
6402
6403   return 1;
6404 }
6405
6406 /* Visible interface to check methods contained in CLASS_DECL */
6407
6408 void
6409 java_check_methods (tree class_decl)
6410 {
6411   if (CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)))
6412     return;
6413
6414   if (CLASS_INTERFACE (class_decl))
6415     java_check_abstract_methods (class_decl);
6416   else
6417     java_check_regular_methods (class_decl);
6418
6419   CLASS_METHOD_CHECKED_P (TREE_TYPE (class_decl)) = 1;
6420 }
6421
6422 /* Like not_accessible_p, but doesn't refer to the current class at
6423    all.  */
6424 static bool
6425 hack_is_accessible_p (tree member, tree from_where)
6426 {
6427   int flags = get_access_flags_from_decl (member);
6428
6429   if (from_where == DECL_CONTEXT (member)
6430       || (flags & ACC_PUBLIC))
6431     return true;
6432
6433   if ((flags & ACC_PROTECTED))
6434     {
6435       if (inherits_from_p (from_where, DECL_CONTEXT (member)))
6436         return true;
6437     }
6438
6439   if ((flags & ACC_PRIVATE))
6440     return false;
6441
6442   /* Package private, or protected.  */
6443   return in_same_package (TYPE_NAME (from_where),
6444                           TYPE_NAME (DECL_CONTEXT (member)));
6445 }
6446
6447 /* Check all the methods of CLASS_DECL. Methods are first completed
6448    then checked according to regular method existence rules.  If no
6449    constructor for CLASS_DECL were encountered, then build its
6450    declaration.  */
6451 static void
6452 java_check_regular_methods (tree class_decl)
6453 {
6454   int saw_constructor = ANONYMOUS_CLASS_P (TREE_TYPE (class_decl));
6455   tree method;
6456   tree class = TREE_TYPE (class_decl);
6457   tree found = NULL_TREE;
6458   tree mthrows;
6459
6460   /* It is not necessary to check methods defined in java.lang.Object */
6461   if (class == object_type_node)
6462     return;
6463
6464   if (!TYPE_NVIRTUALS (class))
6465     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6466
6467   /* Should take interfaces into account. FIXME */
6468   for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
6469     {
6470       tree sig;
6471       tree method_wfl = DECL_FUNCTION_WFL (method);
6472       int aflags;
6473
6474       /* Check for redefinitions */
6475       if (check_method_redefinition (class, method))
6476         continue;
6477
6478       /* We verify things thrown by the method.  They must inherit from
6479          java.lang.Throwable.  */
6480       for (mthrows = DECL_FUNCTION_THROWS (method);
6481            mthrows; mthrows = TREE_CHAIN (mthrows))
6482         {
6483           if (!inherits_from_p (TREE_VALUE (mthrows), throwable_type_node))
6484             parse_error_context
6485               (TREE_PURPOSE (mthrows), "Class %qs in %<throws%> clause must be a subclass of class %<java.lang.Throwable%>",
6486                IDENTIFIER_POINTER
6487                  (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))));
6488         }
6489
6490       /* If we see one constructor a mark so we don't generate the
6491          default one.  Also skip other verifications: constructors
6492          can't be inherited hence hidden or overridden.  */
6493       if (DECL_CONSTRUCTOR_P (method))
6494         {
6495           saw_constructor = 1;
6496           continue;
6497         }
6498
6499       sig = build_java_argument_signature (TREE_TYPE (method));
6500       found = lookup_argument_method_generic (class, DECL_NAME (method), sig,
6501                                               SEARCH_SUPER | SEARCH_INTERFACE);
6502
6503       /* Inner class can't declare static methods */
6504       if (METHOD_STATIC (method) && !TOPLEVEL_CLASS_DECL_P (class_decl))
6505         {
6506           char *t = xstrdup (lang_printable_name (class, 0));
6507           parse_error_context
6508             (method_wfl, "Method %qs can't be static in inner class %qs. Only members of interfaces and top-level classes can be static",
6509              lang_printable_name (method, 2), t);
6510           free (t);
6511         }
6512
6513       /* Nothing overrides or it's a private method. */
6514       if (!found)
6515         continue;
6516       if (METHOD_PRIVATE (found))
6517         {
6518           found = NULL_TREE;
6519           continue;
6520         }
6521
6522       /* If `found' is declared in an interface, make sure the
6523          modifier matches. */
6524       if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6525           && clinit_identifier_node != DECL_NAME (found)
6526           && !METHOD_PUBLIC (method))
6527         {
6528           tree found_decl = TYPE_NAME (DECL_CONTEXT (found));
6529           parse_error_context (method_wfl, "Class %qs must override %qs with a public method in order to implement interface %qs",
6530                                IDENTIFIER_POINTER (DECL_NAME (class_decl)),
6531                                lang_printable_name (found, 0),
6532                                IDENTIFIER_POINTER (DECL_NAME (found_decl)));
6533         }
6534
6535       /* Can't override a method with the same name and different return
6536          types. */
6537       if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
6538         {
6539           char *t = xstrdup
6540             (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 2));
6541           parse_error_context
6542             (method_wfl,
6543              "Method %qs was defined with return type %qs in class %qs",
6544              lang_printable_name (found, 2), t,
6545              IDENTIFIER_POINTER
6546                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6547           free (t);
6548         }
6549
6550       aflags = get_access_flags_from_decl (found);
6551
6552       /* Can't override final. Can't override static. */
6553       if (METHOD_FINAL (found) || METHOD_STATIC (found))
6554         {
6555           /* Static *can* override static */
6556           if (METHOD_STATIC (found) && METHOD_STATIC (method))
6557             continue;
6558           parse_error_context
6559             (method_wfl,
6560              "%s methods can't be overridden. Method %qs is %s in class %qs",
6561              (METHOD_FINAL (found) ? "Final" : "Static"),
6562              lang_printable_name (found, 2),
6563              (METHOD_FINAL (found) ? "final" : "static"),
6564              IDENTIFIER_POINTER
6565                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6566           continue;
6567         }
6568
6569       /* Static method can't override instance method. */
6570       if (METHOD_STATIC (method))
6571         {
6572           parse_error_context
6573             (method_wfl,
6574              "Instance methods can't be overridden by a static method. Method %qs is an instance method in class %qs",
6575              lang_printable_name (found, 2),
6576              IDENTIFIER_POINTER
6577                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6578           continue;
6579         }
6580
6581       /* - Overriding/hiding public must be public
6582          - Overriding/hiding protected must be protected or public
6583          - If the overridden or hidden method has default (package)
6584            access, then the overriding or hiding method must not be
6585            private; otherwise, a compile-time error occurs.  If
6586            `found' belongs to an interface, things have been already
6587            taken care of.  */
6588       if (!CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (found)))
6589           && ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method))
6590               || (METHOD_PROTECTED (found)
6591                   && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method)))
6592               || (!(aflags & (ACC_PUBLIC | ACC_PRIVATE | ACC_STATIC))
6593                   && METHOD_PRIVATE (method))))
6594         {
6595           parse_error_context
6596             (method_wfl,
6597              "Methods can't be overridden to be more private. Method %qs is not %s in class %qs", lang_printable_name (method, 2),
6598              (METHOD_PUBLIC (method) ? "public" :
6599               (METHOD_PRIVATE (method) ? "private" : "protected")),
6600              IDENTIFIER_POINTER (DECL_NAME
6601                                  (TYPE_NAME (DECL_CONTEXT (found)))));
6602           continue;
6603         }
6604
6605       /* Check this method against all the other implementations it
6606          overrides.  Here we only check the class hierarchy; the rest
6607          of the checking is done later.  If this method is just a
6608          Miranda method, we can skip the check.  */
6609       if (! METHOD_INVISIBLE (method))
6610         check_concrete_throws_clauses (class, method, DECL_NAME (method), sig);
6611     }
6612
6613   /* The above throws clause check only looked at superclasses.  Now
6614      we must also make sure that all methods declared in interfaces
6615      have compatible throws clauses.  FIXME: there are more efficient
6616      ways to organize this checking; we should implement one.  */
6617   check_interface_throws_clauses (class, class);
6618
6619   if (!TYPE_NVIRTUALS (class))
6620     TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
6621
6622   /* Search for inherited abstract method not yet implemented in this
6623      class.  */
6624   java_check_abstract_method_definitions (class_decl);
6625
6626   if (!saw_constructor)
6627     abort ();
6628 }
6629
6630 /* Check to make sure that all the methods in all the interfaces
6631    implemented by CLASS_DECL are compatible with the concrete
6632    implementations available in CHECK_CLASS_DECL.  */
6633 static void
6634 check_interface_throws_clauses (tree check_class_decl, tree class_decl)
6635 {
6636   for (; class_decl != NULL_TREE; class_decl = CLASSTYPE_SUPER (class_decl))
6637     {
6638       int i;
6639
6640       if (! CLASS_LOADED_P (class_decl))
6641         {
6642           if (CLASS_FROM_SOURCE_P (class_decl))
6643             safe_layout_class (class_decl);
6644           else
6645             load_class (class_decl, 1);
6646         }
6647
6648       for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (class_decl)) - 1; i > 0; --i)
6649         {
6650           tree interface
6651             = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (class_decl), i));
6652           tree iface_method;
6653
6654           for (iface_method = TYPE_METHODS (interface);
6655                iface_method != NULL_TREE;
6656                iface_method = TREE_CHAIN (iface_method))
6657             {
6658               tree sig, method;
6659
6660               /* First look for a concrete method implemented or
6661                  inherited by this class.  No need to search
6662                  interfaces here, since we're already looking through
6663                  all of them.  */
6664               sig = build_java_argument_signature (TREE_TYPE (iface_method));
6665               method
6666                 = lookup_argument_method_generic (check_class_decl,
6667                                                   DECL_NAME (iface_method),
6668                                                   sig, SEARCH_VISIBLE);
6669               /* If we don't find an implementation, that is ok.  Any
6670                  potential errors from that are diagnosed elsewhere.
6671                  Also, multiple inheritance with conflicting throws
6672                  clauses is fine in the absence of a concrete
6673                  implementation.  */
6674               if (method != NULL_TREE && !METHOD_ABSTRACT (method)
6675                   && !METHOD_INVISIBLE (iface_method))
6676                 {
6677                   tree method_wfl = DECL_FUNCTION_WFL (method);
6678                   check_throws_clauses (method, method_wfl, iface_method);
6679                 }
6680             }
6681
6682           /* Now check superinterfaces.  */
6683           check_interface_throws_clauses (check_class_decl, interface);
6684         }
6685     }
6686 }
6687
6688 /* Check throws clauses of a method against the clauses of all the
6689    methods it overrides.  We do this by searching up the class
6690    hierarchy, examining all matching accessible methods.  */
6691 static void
6692 check_concrete_throws_clauses (tree class, tree self_method,
6693                                tree name, tree signature)
6694 {
6695   tree method = lookup_argument_method_generic (class, name, signature,
6696                                                 SEARCH_SUPER | SEARCH_VISIBLE);
6697   while (method != NULL_TREE)
6698     {
6699       if (! METHOD_INVISIBLE (method) && hack_is_accessible_p (method, class))
6700         check_throws_clauses (self_method, DECL_FUNCTION_WFL (self_method),
6701                               method);
6702
6703       method = lookup_argument_method_generic (DECL_CONTEXT (method),
6704                                                name, signature,
6705                                                SEARCH_SUPER | SEARCH_VISIBLE);
6706     }
6707 }
6708
6709 /* Generate an error if the `throws' clause of METHOD (if any) is
6710    incompatible with the `throws' clause of FOUND (if any).  */
6711 static void
6712 check_throws_clauses (tree method, tree method_wfl, tree found)
6713 {
6714   tree mthrows;
6715
6716   for (mthrows = DECL_FUNCTION_THROWS (method);
6717        mthrows; mthrows = TREE_CHAIN (mthrows))
6718     {
6719       tree fthrows;
6720
6721       /* We don't verify unchecked expressions */
6722       if (IS_UNCHECKED_EXCEPTION_P (TREE_VALUE (mthrows)))
6723         continue;
6724       /* Checked expression must be compatible */
6725       for (fthrows = DECL_FUNCTION_THROWS (found);
6726            fthrows; fthrows = TREE_CHAIN (fthrows))
6727         {
6728           if (inherits_from_p (TREE_VALUE (mthrows), TREE_VALUE (fthrows)))
6729             break;
6730         }
6731       if (!fthrows)
6732         {
6733           parse_error_context
6734             (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",
6735              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (TREE_VALUE (mthrows)))),
6736              lang_printable_name (found, 2),
6737              IDENTIFIER_POINTER
6738              (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6739         }
6740     }
6741 }
6742
6743 /* Check abstract method of interface INTERFACE */
6744 static void
6745 java_check_abstract_methods (tree interface_decl)
6746 {
6747   int i;
6748   tree method, found;
6749   tree interface = TREE_TYPE (interface_decl);
6750   tree base_binfo;
6751
6752   for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
6753     {
6754       /* 2- Check for double definition inside the defining interface */
6755       if (check_method_redefinition (interface, method))
6756         continue;
6757
6758       /* 3- Overriding is OK as far as we preserve the return type.  */
6759       found = lookup_java_interface_method2 (interface, method);
6760       if (found)
6761         {
6762           char *t;
6763           t = xstrdup (lang_printable_name (TREE_TYPE (TREE_TYPE (found)), 2));
6764           parse_error_context
6765             (DECL_FUNCTION_WFL (found),
6766              "Method %qs was defined with return type %qs in class %qs",
6767              lang_printable_name (found, 2), t,
6768              IDENTIFIER_POINTER
6769                (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6770           free (t);
6771           continue;
6772         }
6773     }
6774
6775   /* 4- Inherited methods can't differ by their returned types */
6776   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (interface), i, base_binfo); i++)
6777     {
6778       tree sub_interface_method, sub_interface;
6779
6780       sub_interface = BINFO_TYPE (base_binfo);
6781       for (sub_interface_method = TYPE_METHODS (sub_interface);
6782            sub_interface_method;
6783            sub_interface_method = TREE_CHAIN (sub_interface_method))
6784         {
6785           found = lookup_java_interface_method2 (interface,
6786                                                  sub_interface_method);
6787           if (found && (found != sub_interface_method))
6788             {
6789               parse_error_context
6790                 (lookup_cl (sub_interface_method),
6791                  "Interface %qs inherits method %qs from interface %qs. This method is redefined with a different return type in interface %qs",
6792                  IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
6793                  lang_printable_name (found, 2),
6794                  IDENTIFIER_POINTER
6795                    (DECL_NAME (TYPE_NAME
6796                                (DECL_CONTEXT (sub_interface_method)))),
6797                  IDENTIFIER_POINTER
6798                    (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
6799             }
6800         }
6801     }
6802 }
6803
6804 /* Lookup methods in interfaces using their name and partial
6805    signature. Return a matching method only if their types differ.  */
6806
6807 static tree
6808 lookup_java_interface_method2 (tree class, tree method_decl)
6809 {
6810   int i;
6811   tree base_binfo;
6812   tree to_return;
6813
6814   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6815     {
6816       if ((BINFO_TYPE (base_binfo) != object_type_node)
6817           && (to_return =
6818               lookup_java_method2 (BINFO_TYPE (base_binfo), method_decl, 1)))
6819         return to_return;
6820     }
6821   for (i = 0; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
6822     {
6823       to_return = lookup_java_interface_method2
6824         (BINFO_TYPE (base_binfo), method_decl);
6825       if (to_return)
6826         return to_return;
6827     }
6828
6829   return NULL_TREE;
6830 }
6831
6832 /* Lookup method using their name and partial signature. Return a
6833    matching method only if their types differ.  */
6834
6835 static tree
6836 lookup_java_method2 (tree clas, tree method_decl, int do_interface)
6837 {
6838   tree method, method_signature, method_name, method_type, name;
6839
6840   method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
6841   name = DECL_NAME (method_decl);
6842   method_name = (TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6843                  EXPR_WFL_NODE (name) : name);
6844   method_type = TREE_TYPE (TREE_TYPE (method_decl));
6845
6846   while (clas != NULL_TREE)
6847     {
6848       for (method = TYPE_METHODS (clas);
6849            method != NULL_TREE;  method = TREE_CHAIN (method))
6850         {
6851           tree method_sig = build_java_argument_signature (TREE_TYPE (method));
6852           tree name = DECL_NAME (method);
6853           if ((TREE_CODE (name) == EXPR_WITH_FILE_LOCATION ?
6854                EXPR_WFL_NODE (name) : name) == method_name
6855               && method_sig == method_signature
6856               && TREE_TYPE (TREE_TYPE (method)) != method_type)
6857             return method;
6858         }
6859       clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
6860     }
6861   return NULL_TREE;
6862 }
6863
6864 /* Return the line that matches DECL line number, and try its best to
6865    position the column number. Used during error reports.
6866    FUTURE/FIXME: return source_location instead of node. */
6867
6868 static GTY(()) tree cl_v;
6869 static tree
6870 lookup_cl (tree decl)
6871 {
6872 #ifndef USE_MAPPED_LOCATION
6873   char *line, *found;
6874 #endif
6875
6876   if (!decl)
6877     return NULL_TREE;
6878
6879   if (cl_v == NULL_TREE)
6880     {
6881       cl_v = build_unknown_wfl (NULL_TREE);
6882     }
6883
6884 #ifdef USE_MAPPED_LOCATION
6885   SET_EXPR_LOCATION (cl_v, DECL_SOURCE_LOCATION (decl));
6886 #else
6887   EXPR_WFL_FILENAME_NODE (cl_v) = get_identifier (DECL_SOURCE_FILE (decl));
6888   EXPR_WFL_SET_LINECOL (cl_v, DECL_SOURCE_LINE (decl), -1);
6889
6890   line = java_get_line_col (EXPR_WFL_FILENAME (cl_v),
6891                             EXPR_WFL_LINENO (cl_v), EXPR_WFL_COLNO (cl_v));
6892
6893   found = strstr ((const char *)line,
6894                   (const char *)IDENTIFIER_POINTER (DECL_NAME (decl)));
6895   if (found)
6896     EXPR_WFL_SET_LINECOL (cl_v, EXPR_WFL_LINENO (cl_v), found - line);
6897 #endif
6898
6899   return cl_v;
6900 }
6901
6902 /* Look for a simple name in the single-type import list */
6903
6904 static tree
6905 find_name_in_single_imports (tree name)
6906 {
6907   tree node;
6908
6909   for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
6910     if (TREE_VALUE (node) == name)
6911       return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
6912
6913   return NULL_TREE;
6914 }
6915
6916 /* Process all single-type import. */
6917
6918 static int
6919 process_imports (void)
6920 {
6921   tree import;
6922   int error_found;
6923
6924   for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
6925     {
6926       tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
6927       char *original_name;
6928
6929       /* Don't load twice something already defined. */
6930       if (IDENTIFIER_CLASS_VALUE (to_be_found))
6931         continue;
6932
6933       original_name = xmemdup (IDENTIFIER_POINTER (to_be_found),
6934                                IDENTIFIER_LENGTH (to_be_found),
6935                                IDENTIFIER_LENGTH (to_be_found) + 1);
6936
6937       while (1)
6938         {
6939           tree left;
6940
6941           QUALIFIED_P (to_be_found) = 1;
6942           load_class (to_be_found, 0);
6943           error_found =
6944             check_pkg_class_access (to_be_found, TREE_PURPOSE (import), true, NULL_TREE);
6945
6946           /* We found it, we can bail out */
6947           if (IDENTIFIER_CLASS_VALUE (to_be_found))
6948             {
6949               check_deprecation (TREE_PURPOSE (import),
6950                                  IDENTIFIER_CLASS_VALUE (to_be_found));
6951               break;
6952             }
6953
6954           /* We haven't found it. Maybe we're trying to access an
6955              inner class.  The only way for us to know is to try again
6956              after having dropped a qualifier. If we can't break it further,
6957              we have an error. */
6958           if (split_qualified_name (&left, NULL, to_be_found))
6959             break;
6960
6961           to_be_found = left;
6962         }
6963       if (!IDENTIFIER_CLASS_VALUE (to_be_found))
6964         {
6965           parse_error_context (TREE_PURPOSE (import),
6966                                "Class or interface %qs not found in import",
6967                                original_name);
6968           error_found = 1;
6969         }
6970
6971       free (original_name);
6972       if (error_found)
6973         return 1;
6974     }
6975   return 0;
6976 }
6977
6978 /* Possibly find and mark a class imported by a single-type import
6979    statement.  */
6980
6981 static void
6982 find_in_imports (tree enclosing_type, tree class_type)
6983 {
6984   tree import;
6985   if (enclosing_type && TYPE_IMPORT_LIST (enclosing_type))
6986     import = TYPE_IMPORT_LIST (enclosing_type);
6987   else
6988     import = ctxp->import_list;
6989
6990   while (import)
6991     {
6992       if (TREE_VALUE (import) == TYPE_NAME (class_type))
6993         {
6994           TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
6995           QUALIFIED_P (TYPE_NAME (class_type)) = 1;
6996           return;
6997         }
6998       import = TREE_CHAIN (import);
6999     }
7000 }
7001
7002 static int
7003 note_possible_classname (const char *name, int len)
7004 {
7005   tree node;
7006   if (len > 5 && strncmp (&name [len-5], ".java", 5) == 0)
7007     len = len - 5;
7008   else if (len > 6 && strncmp (&name [len-6], ".class", 6) == 0)
7009     len = len - 6;
7010   else
7011     return 0;
7012   node = ident_subst (name, len, "", '/', '.', "");
7013   IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
7014   QUALIFIED_P (node) = strchr (name, '/') ? 1 : 0;
7015   return 1;
7016 }
7017
7018 /* Read a import directory, gathering potential match for further type
7019    references. Indifferently reads a filesystem or a ZIP archive
7020    directory.  */
7021
7022 static void
7023 read_import_dir (tree wfl)
7024 {
7025   tree package_id = EXPR_WFL_NODE (wfl);
7026   const char *package_name = IDENTIFIER_POINTER (package_id);
7027   int package_length = IDENTIFIER_LENGTH (package_id);
7028   DIR *dirp = NULL;
7029   JCF *saved_jcf = current_jcf;
7030
7031   int found = 0;
7032   int k;
7033   void *entry;
7034   struct buffer filename[1];
7035
7036   if (IS_AN_IMPORT_ON_DEMAND_P (package_id))
7037     return;
7038   IS_AN_IMPORT_ON_DEMAND_P (package_id) = 1;
7039
7040   BUFFER_INIT (filename);
7041   buffer_grow (filename, package_length + 100);
7042
7043   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
7044     {
7045       const char *entry_name = jcf_path_name (entry);
7046       int entry_length = strlen (entry_name);
7047       if (jcf_path_is_zipfile (entry))
7048         {
7049           ZipFile *zipf;
7050           buffer_grow (filename, entry_length);
7051           memcpy (filename->data, entry_name, entry_length - 1);
7052           filename->data[entry_length-1] = '\0';
7053           zipf = opendir_in_zip ((const char *) filename->data, jcf_path_is_system (entry));
7054           if (zipf == NULL)
7055             error ("malformed .zip archive in CLASSPATH: %s", entry_name);
7056           else
7057             {
7058               ZipDirectory *zipd = (ZipDirectory *) zipf->central_directory;
7059               BUFFER_RESET (filename);
7060               for (k = 0; k < package_length; k++)
7061                 {
7062                   char ch = package_name[k];
7063                   *filename->ptr++ = ch == '.' ? '/' : ch;
7064                 }
7065               *filename->ptr++ = '/';
7066
7067               for (k = 0; k < zipf->count;  k++, zipd = ZIPDIR_NEXT (zipd))
7068                 {
7069                   const char *current_entry = ZIPDIR_FILENAME (zipd);
7070                   int current_entry_len = zipd->filename_length;
7071
7072                   if (current_entry_len >= BUFFER_LENGTH (filename)
7073                       && strncmp ((const char *) filename->data, current_entry,
7074                                   BUFFER_LENGTH (filename)) != 0)
7075                     continue;
7076                   found |= note_possible_classname (current_entry,
7077                                                     current_entry_len);
7078                 }
7079             }
7080         }
7081       else
7082         {
7083           BUFFER_RESET (filename);
7084           buffer_grow (filename, entry_length + package_length + 4);
7085           strcpy ((char *) filename->data, entry_name);
7086           filename->ptr = filename->data + entry_length;
7087           for (k = 0; k < package_length; k++)
7088             {
7089               char ch = package_name[k];
7090               *filename->ptr++ = ch == '.' ? '/' : ch;
7091             }
7092           *filename->ptr = '\0';
7093
7094           dirp = opendir ((const char *) filename->data);
7095           if (dirp == NULL)
7096             continue;
7097           *filename->ptr++ = '/';
7098           for (;;)
7099             {
7100               int len;
7101               const char *d_name;
7102               struct dirent *direntp = readdir (dirp);
7103               if (!direntp)
7104                 break;
7105               d_name = direntp->d_name;
7106               len = strlen (direntp->d_name);
7107               buffer_grow (filename, len+1);
7108               strcpy ((char *) filename->ptr, d_name);
7109               found |= note_possible_classname ((const char *) filename->data + entry_length,
7110                                                 package_length+len+1);
7111             }
7112           if (dirp)
7113             closedir (dirp);
7114         }
7115     }
7116
7117   free (filename->data);
7118
7119   /* Here we should have a unified way of retrieving an entry, to be
7120      indexed. */
7121   if (!found)
7122     {
7123       static int first = 1;
7124       if (first)
7125         {
7126           error ("Can't find default package %qs. Check the CLASSPATH environment variable and the access to the archives", package_name);
7127           java_error_count++;
7128           first = 0;
7129         }
7130       else
7131         parse_error_context (wfl, "Package %qs not found in import",
7132                              package_name);
7133       current_jcf = saved_jcf;
7134       return;
7135     }
7136   current_jcf = saved_jcf;
7137 }
7138
7139 /* Possibly find a type in the import on demands specified
7140    types. Returns 1 if an error occurred, 0 otherwise. Run through the
7141    entire list, to detected potential double definitions.  */
7142
7143 static int
7144 find_in_imports_on_demand (tree enclosing_type, tree class_type)
7145 {
7146   tree class_type_name = TYPE_NAME (class_type);
7147   tree cl = NULL_TREE;
7148   int seen_once = -1;   /* -1 when not set, 1 if seen once, >1 otherwise. */
7149   int to_return = -1;   /* -1 when not set, 0 or 1 otherwise */
7150   tree node;
7151   tree import;
7152
7153   if (enclosing_type && TYPE_IMPORT_DEMAND_LIST (enclosing_type))
7154     import = TYPE_IMPORT_DEMAND_LIST (enclosing_type);
7155   else
7156     import = ctxp->import_demand_list;
7157
7158   for (; import; import = TREE_CHAIN (import))
7159     {
7160       location_t saved_location = input_location;
7161       int access_check;
7162       const char *id_name;
7163       tree decl, type_name_copy;
7164
7165       obstack_grow (&temporary_obstack,
7166                     IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
7167                     IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
7168       obstack_1grow (&temporary_obstack, '.');
7169       obstack_grow0 (&temporary_obstack,
7170                      IDENTIFIER_POINTER (class_type_name),
7171                      IDENTIFIER_LENGTH (class_type_name));
7172       id_name = obstack_finish (&temporary_obstack);
7173
7174       if (! (node = maybe_get_identifier (id_name)))
7175         continue;
7176
7177       /* Setup input_line so that it refers to the line of the import (in
7178          case we parse a class file and encounter errors */
7179 #ifdef USE_MAPPED_LOCATION
7180       input_location = EXPR_LOCATION (TREE_PURPOSE (import));
7181 #else
7182       input_line = EXPR_WFL_LINENO (TREE_PURPOSE (import));
7183 #endif
7184
7185       type_name_copy = TYPE_NAME (class_type);
7186       TYPE_NAME (class_type) = node;
7187       QUALIFIED_P (node) = 1;
7188       decl = IDENTIFIER_CLASS_VALUE (node);
7189       access_check = -1;
7190       /* If there is no DECL set for the class or if the class isn't
7191          loaded and not seen in source yet, then load */
7192       if (!decl || ! CLASS_LOADED_P (TREE_TYPE (decl)))
7193         {
7194           load_class (node, 0);
7195           decl = IDENTIFIER_CLASS_VALUE (node);
7196         }
7197       if (decl && ! INNER_CLASS_P (TREE_TYPE (decl)))
7198         access_check = check_pkg_class_access (node, TREE_PURPOSE (import),
7199                                                false, NULL_TREE);
7200       else
7201         /* 6.6.1: Inner classes are subject to member access rules. */
7202         access_check = 0;
7203
7204       input_location = saved_location;
7205
7206       /* If the loaded class is not accessible or couldn't be loaded,
7207          we restore the original TYPE_NAME and process the next
7208          import. */
7209       if (access_check || !decl)
7210         {
7211           TYPE_NAME (class_type) = type_name_copy;
7212           continue;
7213         }
7214
7215       /* If the loaded class is accessible, we keep a tab on it to
7216          detect and report multiple inclusions. */
7217       if (IS_A_CLASSFILE_NAME (node))
7218         {
7219           if (seen_once < 0)
7220             {
7221               cl = TREE_PURPOSE (import);
7222               seen_once = 1;
7223             }
7224           else if (seen_once >= 0)
7225             {
7226               tree location = (cl ? cl : TREE_PURPOSE (import));
7227               tree package = (cl ? EXPR_WFL_NODE (cl) :
7228                               EXPR_WFL_NODE (TREE_PURPOSE (import)));
7229               seen_once++;
7230               parse_error_context
7231                 (location,
7232                  "Type %qs also potentially defined in package %qs",
7233                  IDENTIFIER_POINTER (TYPE_NAME (class_type)),
7234                  IDENTIFIER_POINTER (package));
7235             }
7236         }
7237       to_return = access_check;
7238     }
7239
7240   if (seen_once == 1)
7241     return to_return;
7242   else
7243     return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
7244 }
7245
7246 static tree
7247 resolve_package (tree pkg, tree *next, tree *type_name)
7248 {
7249   tree current;
7250   tree decl = NULL_TREE;
7251   *type_name = NULL_TREE;
7252
7253   /* The trick is to determine when the package name stops and were
7254      the name of something contained in the package starts. Then we
7255      return a fully qualified name of what we want to get. */
7256
7257   *next = EXPR_WFL_QUALIFICATION (pkg);
7258
7259   /* Try to progressively construct a type name */
7260   if (TREE_CODE (pkg) == EXPR_WITH_FILE_LOCATION)
7261     for (current = EXPR_WFL_QUALIFICATION (pkg);
7262          current; current = TREE_CHAIN (current))
7263       {
7264         /* If we don't have what we're expecting, exit now. TYPE_NAME
7265            will be null and the error caught later. */
7266         if (TREE_CODE (QUAL_WFL (current)) != EXPR_WITH_FILE_LOCATION)
7267           break;
7268         *type_name =
7269           merge_qualified_name (*type_name, EXPR_WFL_NODE (QUAL_WFL (current)));
7270         if ((decl = resolve_no_layout (*type_name, NULL_TREE)))
7271           {
7272             /* resolve_package should be used in a loop, hence we
7273                point at this one to naturally process the next one at
7274                the next iteration. */
7275             *next = current;
7276             break;
7277           }
7278       }
7279   return decl;
7280 }
7281
7282 /* Check accessibility of inner class DECL, from the context ENCLOSING_DECL,
7283    according to member access rules.  */
7284
7285 static bool
7286 inner_class_accessible (tree decl, tree enclosing_decl)
7287 {
7288   tree enclosing_decl_type;
7289
7290   enclosing_decl_type = TREE_TYPE (enclosing_decl);
7291
7292   if (CLASS_PRIVATE (decl))
7293     {
7294       /* Access is permitted only within the body of the top-level
7295          class in which DECL is declared. */
7296       tree top_level = decl;
7297       while (DECL_CONTEXT (top_level))
7298         top_level = DECL_CONTEXT (top_level);
7299       while (DECL_CONTEXT (enclosing_decl))
7300         enclosing_decl = DECL_CONTEXT (enclosing_decl);
7301       if (top_level == enclosing_decl)
7302         return true;
7303     }
7304   else if (CLASS_PROTECTED (decl))
7305     {
7306       tree decl_context;
7307       /* Access is permitted from within the same package... */
7308       if (in_same_package (decl, enclosing_decl))
7309         return true;
7310
7311       /* ... or from within the body of a subtype of the context in which
7312          DECL is declared. */
7313       decl_context = DECL_CONTEXT (decl);
7314       while (enclosing_decl)
7315         {
7316           if (CLASS_INTERFACE (decl))
7317             {
7318               if (interface_of_p (TREE_TYPE (decl_context),
7319                                   enclosing_decl_type))
7320                 return true;
7321             }
7322           else
7323             {
7324               /* Eww. The order of the arguments is different!! */
7325               if (inherits_from_p (enclosing_decl_type,
7326                                    TREE_TYPE (decl_context)))
7327                 return true;
7328             }
7329           enclosing_decl = DECL_CONTEXT (enclosing_decl);
7330         }
7331     }
7332   else if (! CLASS_PUBLIC (decl))
7333     {
7334       /* Access is permitted only from within the same package as DECL. */
7335       if (in_same_package (decl, enclosing_decl))
7336         return true;
7337     }
7338   else
7339     /* Class is public. */
7340     return true;
7341
7342   return false;
7343 }
7344
7345 /* Check accessibility of inner classes according to member access rules.
7346    DECL is the inner class, ENCLOSING_DECL is the class from which the
7347    access is being attempted. */
7348
7349 static void
7350 check_inner_class_access (tree decl, tree enclosing_decl, tree cl)
7351 {
7352   const char *access;
7353
7354   /* We don't issue an error message when CL is null. CL can be null
7355      as a result of processing a JDEP crafted by source_start_java_method
7356      for the purpose of patching its parm decl. But the error would
7357      have been already trapped when fixing the method's signature.
7358      DECL can also be NULL in case of earlier errors. */
7359   if (!decl || !cl)
7360     return;
7361
7362   if (inner_class_accessible (decl, enclosing_decl))
7363     return;
7364
7365   if (CLASS_PRIVATE (decl))
7366       access = "private";
7367   else if (CLASS_PROTECTED (decl))
7368       access = "protected";
7369   else
7370       access = "non-public";
7371
7372   parse_error_context (cl, "Nested %s %s is %s; cannot be accessed from here",
7373                        (CLASS_INTERFACE (decl) ? "interface" : "class"),
7374                        lang_printable_name (decl, 2), access);
7375 }
7376
7377 /* Accessibility check for top-level classes. If CLASS_NAME is in a
7378    foreign package, it must be PUBLIC. Return 0 if no access
7379    violations were found, 1 otherwise. If VERBOSE is true and an error
7380    was found, it is reported and accounted for.  If CL is NULL then
7381    look it up with THIS_DECL.  */
7382
7383 static int
7384 check_pkg_class_access (tree class_name, tree cl, bool verbose, tree this_decl)
7385 {
7386   tree type;
7387
7388   if (!IDENTIFIER_CLASS_VALUE (class_name))
7389     return 0;
7390
7391   if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
7392     return 0;
7393
7394   if (!CLASS_PUBLIC (TYPE_NAME (type)))
7395     {
7396       /* Access to a private class within the same package is
7397          allowed. */
7398       tree l, r;
7399       split_qualified_name (&l, &r, class_name);
7400       if (!QUALIFIED_P (class_name) && !ctxp->package)
7401         /* Both in the empty package. */
7402         return 0;
7403       if (l == ctxp->package)
7404         /* Both in the same package. */
7405         return 0;
7406
7407       if (verbose)
7408         parse_error_context
7409           (cl == NULL ? lookup_cl (this_decl): cl,
7410            "Can't access %s %qs. Only public classes and interfaces in other packages can be accessed",
7411            (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
7412            IDENTIFIER_POINTER (class_name));
7413       return 1;
7414     }
7415   return 0;
7416 }
7417
7418 /* Local variable declaration. */
7419
7420 static void
7421 declare_local_variables (int modifier, tree type, tree vlist)
7422 {
7423   tree decl, current, saved_type;
7424   tree type_wfl = NULL_TREE;
7425   int must_chain = 0;
7426   int final_p = 0;
7427
7428   /* Push a new block if statements were seen between the last time we
7429      pushed a block and now. Keep a count of blocks to close */
7430   if (BLOCK_EXPR_BODY (GET_CURRENT_BLOCK (current_function_decl)))
7431     {
7432       tree b = enter_block ();
7433       BLOCK_IS_IMPLICIT (b) = 1;
7434     }
7435
7436   if (modifier)
7437     {
7438       size_t i;
7439       for (i = 0; i < ARRAY_SIZE (ctxp->modifier_ctx); i++)
7440         if (1 << i & modifier)
7441           break;
7442       if (modifier == ACC_FINAL)
7443         final_p = 1;
7444       else
7445         {
7446           parse_error_context
7447             (ctxp->modifier_ctx [i],
7448              "Only %<final%> is allowed as a local variables modifier");
7449           return;
7450         }
7451     }
7452
7453   /* Obtain an incomplete type if TYPE is not complete. TYPE_WFL will
7454      hold the TYPE value if a new incomplete has to be created (as
7455      opposed to being found already existing and reused). */
7456   SET_TYPE_FOR_RESOLUTION (type, type_wfl, must_chain);
7457
7458   /* If TYPE is fully resolved and we don't have a reference, make one */
7459   PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7460
7461   /* Go through all the declared variables */
7462   for (current = vlist, saved_type = type; current;
7463        current = TREE_CHAIN (current), type = saved_type)
7464     {
7465       tree other, real_type;
7466       tree wfl  = TREE_PURPOSE (current);
7467       tree name = EXPR_WFL_NODE (wfl);
7468       tree init = TREE_VALUE (current);
7469
7470       /* Process NAME, as it may specify extra dimension(s) for it */
7471       type = build_array_from_name (type, type_wfl, name, &name);
7472
7473       /* Variable redefinition check */
7474       if ((other = lookup_name_in_blocks (name)))
7475         {
7476           variable_redefinition_error (wfl, name, TREE_TYPE (other),
7477                                        DECL_SOURCE_LINE (other));
7478           continue;
7479         }
7480
7481       /* Type adjustment. We may have just readjusted TYPE because
7482          the variable specified more dimensions. Make sure we have
7483          a reference if we can and don't have one already. */
7484       PROMOTE_RECORD_IF_COMPLETE (type, must_chain);
7485
7486       real_type = GET_REAL_TYPE (type);
7487       /* Never layout this decl. This will be done when its scope
7488          will be entered */
7489       decl = build_decl (VAR_DECL, name, real_type);
7490       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
7491       DECL_FINAL (decl) = final_p;
7492       BLOCK_CHAIN_DECL (decl);
7493
7494       /* Don't try to use an INIT statement when an error was found */
7495       if (init && java_error_count)
7496         init = NULL_TREE;
7497
7498       /* Remember it if this is an initialized-upon-declaration final
7499          variable.  */
7500       if (init && final_p)
7501         {
7502           DECL_LOCAL_FINAL_IUD (decl) = 1;
7503         }
7504
7505       /* Add the initialization function to the current function's code */
7506       if (init)
7507         {
7508           /* Name might have been readjusted */
7509           EXPR_WFL_NODE (TREE_OPERAND (init, 0)) = name;
7510           MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
7511           java_method_add_stmt (current_function_decl,
7512                                 build_debugable_stmt (EXPR_WFL_LINECOL (init),
7513                                                       init));
7514         }
7515
7516       /* Setup dependency the type of the decl */
7517       if (must_chain)
7518         {
7519           jdep *dep;
7520           register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
7521           dep = CLASSD_LAST (ctxp->classd_list);
7522           JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
7523         }
7524     }
7525   SOURCE_FRONTEND_DEBUG (("Defined locals"));
7526 }
7527
7528 /* Called during parsing. Build decls from argument list.  */
7529
7530 static void
7531 source_start_java_method (tree fndecl)
7532 {
7533   tree tem;
7534   tree parm_decl;
7535   int i;
7536
7537   if (!fndecl)
7538     return;
7539
7540   current_function_decl = fndecl;
7541
7542   /* New scope for the function */
7543   enter_block ();
7544   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
7545        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
7546     {
7547       tree type = TREE_VALUE (tem);
7548       tree name = TREE_PURPOSE (tem);
7549
7550       /* If type is incomplete. Create an incomplete decl and ask for
7551          the decl to be patched later */
7552       if (INCOMPLETE_TYPE_P (type))
7553         {
7554           jdep *jdep;
7555           tree real_type = GET_REAL_TYPE (type);
7556           parm_decl = build_decl (PARM_DECL, name, real_type);
7557           type = obtain_incomplete_type (type);
7558           register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
7559           jdep = CLASSD_LAST (ctxp->classd_list);
7560           JDEP_MISC (jdep) = name;
7561           JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
7562         }
7563       else
7564         parm_decl = build_decl (PARM_DECL, name, type);
7565
7566       /* Remember if a local variable was declared final (via its
7567          TREE_LIST of type/name.) Set DECL_FINAL accordingly. */
7568       if (ARG_FINAL_P (tem))
7569         {
7570           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (parm_decl);
7571           DECL_FINAL (parm_decl) = 1;
7572         }
7573
7574       if (name == this_identifier_node)
7575         DECL_ARTIFICIAL (parm_decl) = 1;
7576
7577       BLOCK_CHAIN_DECL (parm_decl);
7578     }
7579   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
7580   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
7581     nreverse (tem);
7582   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
7583   DECL_MAX_LOCALS (current_function_decl) = i;
7584 }
7585
7586 /* Called during parsing. Creates an artificial method declaration.  */
7587
7588 static tree
7589 create_artificial_method (tree class, int flags, tree type,
7590                           tree name, tree args)
7591 {
7592   tree mdecl;
7593   location_t save_location = input_location;
7594
7595   input_location = DECL_SOURCE_LOCATION (TYPE_NAME (class));
7596   mdecl = make_node (FUNCTION_TYPE);
7597   TREE_TYPE (mdecl) = type;
7598   TYPE_ARG_TYPES (mdecl) = args;
7599   /* We used to compute the signature of MDECL here and then use
7600      add_method(), but that failed because our caller might modify
7601      the type of the returned method, which trashes the cache in
7602      get_type_from_signature().  */
7603   mdecl = add_method_1 (class, flags, name, mdecl);
7604   input_location = save_location;
7605   DECL_ARTIFICIAL (mdecl) = 1;
7606   return mdecl;
7607 }
7608
7609 /* Starts the body if an artificial method.  */
7610
7611 static void
7612 start_artificial_method_body (tree mdecl)
7613 {
7614 #ifdef USE_MAPPED_LOCATION
7615   DECL_SOURCE_LOCATION (mdecl) = ctxp->file_start_location;
7616   DECL_FUNCTION_LAST_LINE (mdecl) = ctxp->file_start_location;
7617 #else
7618   DECL_SOURCE_LINE (mdecl) = 1;
7619   DECL_FUNCTION_LAST_LINE (mdecl) = 1;
7620 #endif
7621   source_start_java_method (mdecl);
7622   enter_block ();
7623 }
7624
7625 static void
7626 end_artificial_method_body (tree mdecl)
7627 {
7628   /* exit_block modifies DECL_FUNCTION_BODY (current_function_decl).
7629      It has to be evaluated first. (if mdecl is current_function_decl,
7630      we have an undefined behavior if no temporary variable is used.) */
7631   tree b = exit_block ();
7632   BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = b;
7633   exit_block ();
7634 }
7635
7636 /* Dump a tree of some kind.  This is a convenience wrapper for the
7637    dump_* functions in tree-dump.c.  */
7638 static void
7639 dump_java_tree (enum tree_dump_index phase, tree t)
7640 {
7641   FILE *stream;
7642   int flags;
7643
7644   stream = dump_begin (phase, &flags);
7645   flags |= TDF_SLIM;
7646   if (stream)
7647     {
7648       dump_node (t, flags, stream);
7649       dump_end (phase, stream);
7650     }
7651 }
7652
7653 /* Terminate a function and expand its body.  */
7654
7655 static void
7656 source_end_java_method (void)
7657 {
7658   tree fndecl = current_function_decl;
7659
7660   if (!fndecl)
7661     return;
7662
7663   java_parser_context_save_global ();
7664 #ifdef USE_MAPPED_LOCATION
7665   input_location = ctxp->last_ccb_indent1;
7666 #else
7667   input_line = ctxp->last_ccb_indent1;
7668 #endif
7669
7670   /* Turn function bodies with only a NOP expr null, so they don't get
7671      generated at all and we won't get warnings when using the -W
7672      -Wall flags. */
7673   if (IS_EMPTY_STMT (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))))
7674     BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = NULL_TREE;
7675
7676   if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
7677       && ! flag_emit_class_files)
7678     finish_method (fndecl);
7679
7680   current_function_decl = NULL_TREE;
7681   java_parser_context_restore_global ();
7682   current_function_decl = NULL_TREE;
7683 }
7684
7685 /* Record EXPR in the current function block. Complements compound
7686    expression second operand if necessary.  */
7687
7688 tree
7689 java_method_add_stmt (tree fndecl, tree expr)
7690 {
7691   if (!GET_CURRENT_BLOCK (fndecl))
7692     return NULL_TREE;
7693   return add_stmt_to_block (GET_CURRENT_BLOCK (fndecl), NULL_TREE, expr);
7694 }
7695
7696 static tree
7697 add_stmt_to_block (tree b, tree type, tree stmt)
7698 {
7699   tree body = BLOCK_EXPR_BODY (b), c;
7700
7701   if (java_error_count)
7702     return body;
7703
7704   if ((c = add_stmt_to_compound (body, type, stmt)) == body)
7705     return body;
7706
7707   BLOCK_EXPR_BODY (b) = c;
7708   TREE_SIDE_EFFECTS (c) = 1;
7709   return c;
7710 }
7711
7712 /* Lays out the methods for the classes seen so far.  */
7713
7714 void
7715 java_layout_seen_class_methods (void)
7716 {
7717   tree previous_list = all_class_list;
7718   tree end = NULL_TREE;
7719   tree current;
7720
7721   while (1)
7722     {
7723       for (current = previous_list;
7724            current != end; current = TREE_CHAIN (current))
7725         {
7726           tree decl = TREE_VALUE (current);
7727           tree cls = TREE_TYPE (decl);
7728
7729           input_location = DECL_SOURCE_LOCATION (decl);
7730
7731           if (! CLASS_LOADED_P (cls))
7732             load_class (cls, 0);
7733
7734           layout_class_methods (cls);
7735         }
7736
7737       /* Note that new classes might have been added while laying out
7738          methods, changing the value of all_class_list.  */
7739
7740       if (previous_list != all_class_list)
7741         {
7742           end = previous_list;
7743           previous_list = all_class_list;
7744         }
7745       else
7746         break;
7747     }
7748 }
7749
7750 static GTY(()) tree stop_reordering;
7751 void
7752 java_reorder_fields (void)
7753 {
7754   tree current;
7755
7756   for (current = gclass_list; current; current = TREE_CHAIN (current))
7757     {
7758       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7759
7760       if (current_class == stop_reordering)
7761         break;
7762
7763       /* Reverse the fields, but leave the dummy field in front.
7764          Fields are already ordered for Object and Class */
7765       if (TYPE_FIELDS (current_class) && current_class != object_type_node
7766           && current_class != class_type_node)
7767       {
7768         /* If the dummy field is there, reverse the right fields and
7769            just layout the type for proper fields offset */
7770         if (!DECL_NAME (TYPE_FIELDS (current_class)))
7771           {
7772             tree fields = TYPE_FIELDS (current_class);
7773             /* This works around a problem where on some platforms,
7774                the field might be given its size incorrectly.  */
7775             DECL_SIZE (fields) = NULL_TREE;
7776             DECL_SIZE_UNIT (fields) = NULL_TREE;
7777             TREE_CHAIN (fields) = nreverse (TREE_CHAIN (fields));
7778             TYPE_SIZE (current_class) = NULL_TREE;
7779           }
7780         /* We don't have a dummy field, we need to layout the class,
7781            after having reversed the fields */
7782         else
7783           {
7784             TYPE_FIELDS (current_class) =
7785               nreverse (TYPE_FIELDS (current_class));
7786             TYPE_SIZE (current_class) = NULL_TREE;
7787           }
7788       }
7789     }
7790   /* There are cases were gclass_list will be empty. */
7791   if (gclass_list)
7792     stop_reordering = TREE_TYPE (TREE_VALUE (gclass_list));
7793 }
7794
7795 /* Layout the methods of all classes loaded in one way or another.
7796    Check methods of source parsed classes. Then reorder the
7797    fields and layout the classes or the type of all source parsed
7798    classes */
7799
7800 void
7801 java_layout_classes (void)
7802 {
7803   tree current;
7804   int save_error_count = java_error_count;
7805
7806   /* Layout the methods of all classes seen so far */
7807   java_layout_seen_class_methods ();
7808   java_parse_abort_on_error ();
7809   all_class_list = NULL_TREE;
7810
7811   /* Then check the methods of all parsed classes */
7812   for (current = gclass_list; current; current = TREE_CHAIN (current))
7813     if (CLASS_FROM_SOURCE_P (TREE_TYPE (TREE_VALUE (current))))
7814       java_check_methods (TREE_VALUE (current));
7815   java_parse_abort_on_error ();
7816
7817   for (current = gclass_list; current; current = TREE_CHAIN (current))
7818     {
7819       output_class = current_class = TREE_TYPE (TREE_VALUE (current));
7820       layout_class (current_class);
7821
7822       /* Error reported by the caller */
7823       if (java_error_count)
7824         return;
7825     }
7826
7827   /* We might have reloaded classes durign the process of laying out
7828      classes for code generation. We must layout the methods of those
7829      late additions, as constructor checks might use them */
7830   java_layout_seen_class_methods ();
7831   java_parse_abort_on_error ();
7832 }
7833
7834 /* Expand methods in the current set of classes remembered for
7835    generation.  */
7836
7837 static void
7838 java_complete_expand_classes (void)
7839 {
7840   tree current;
7841
7842   for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
7843     if (!INNER_CLASS_DECL_P (current))
7844       java_complete_expand_class (current);
7845 }
7846
7847 /* Expand the methods found in OUTER, starting first by OUTER's inner
7848    classes, if any.  */
7849
7850 static void
7851 java_complete_expand_class (tree outer)
7852 {
7853   tree inner_list;
7854
7855   /* We need to go after all inner classes and start expanding them,
7856      starting with most nested ones. We have to do that because nested
7857      classes might add functions to outer classes */
7858
7859   for (inner_list = DECL_INNER_CLASS_LIST (outer);
7860        inner_list; inner_list = TREE_CHAIN (inner_list))
7861     java_complete_expand_class (TREE_PURPOSE (inner_list));
7862
7863   java_complete_expand_methods (outer);
7864 }
7865
7866 /* Expand methods registered in CLASS_DECL. The general idea is that
7867    we expand regular methods first. This allows us get an estimate on
7868    how outer context local alias fields are really used so we can add
7869    to the constructor just enough code to initialize them properly (it
7870    also lets us generate finit$ correctly.) Then we expand the
7871    constructors and then <clinit>.  */
7872
7873 static void
7874 java_complete_expand_methods (tree class_decl)
7875 {
7876   tree clinit, decl, first_decl;
7877
7878   output_class = current_class = TREE_TYPE (class_decl);
7879
7880   /* Pre-expand <clinit> to figure whether we really need it or
7881      not. If we do need it, we pre-expand the static fields so they're
7882      ready to be used somewhere else. <clinit> will be fully expanded
7883      after we processed the constructors. */
7884   first_decl = TYPE_METHODS (current_class);
7885   clinit = maybe_generate_pre_expand_clinit (current_class);
7886
7887   /* Then generate finit$ (if we need to) because constructors will
7888    try to use it.*/
7889   if (TYPE_FINIT_STMT_LIST (current_class))
7890     java_complete_expand_method (generate_finit (current_class));
7891
7892   /* Then generate instinit$ (if we need to) because constructors will
7893      try to use it. */
7894   if (TYPE_II_STMT_LIST (current_class))
7895     java_complete_expand_method (generate_instinit (current_class));
7896
7897   /* Now do the constructors */
7898   for (decl = first_decl ; !java_error_count && decl; decl = TREE_CHAIN (decl))
7899     {
7900       if (!DECL_CONSTRUCTOR_P (decl))
7901         continue;
7902       java_complete_expand_method (decl);
7903     }
7904
7905   /* First, do the ordinary methods. */
7906   for (decl = first_decl; decl; decl = TREE_CHAIN (decl))
7907     {
7908       /* Ctors aren't part of this batch. */
7909       if (DECL_CONSTRUCTOR_P (decl) || DECL_CLINIT_P (decl))
7910         continue;
7911
7912       /* Skip abstract or native methods -- but do handle native
7913          methods when generating JNI stubs.  */
7914       if (METHOD_ABSTRACT (decl) || (! flag_jni && METHOD_NATIVE (decl)))
7915         {
7916           DECL_FUNCTION_BODY (decl) = NULL_TREE;
7917           continue;
7918         }
7919
7920       if (METHOD_NATIVE (decl))
7921         {
7922           tree body;
7923           current_function_decl = decl;
7924           body = build_jni_stub (decl);
7925           BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl)) = body;
7926         }
7927
7928       java_complete_expand_method (decl);
7929     }
7930
7931   /* If there is indeed a <clinit>, fully expand it now */
7932   if (clinit)
7933     {
7934       /* Prevent the use of `this' inside <clinit> */
7935       ctxp->explicit_constructor_p = 1;
7936       java_complete_expand_method (clinit);
7937       ctxp->explicit_constructor_p = 0;
7938     }
7939
7940   /* We might have generated a class$ that we now want to expand */
7941   if (TYPE_DOT_CLASS (current_class))
7942     java_complete_expand_method (TYPE_DOT_CLASS (current_class));
7943
7944   /* Now verify constructor circularity (stop after the first one we
7945      prove wrong.) */
7946   if (!CLASS_INTERFACE (class_decl))
7947     for (decl = TYPE_METHODS (current_class); decl; decl = TREE_CHAIN (decl))
7948       if (DECL_CONSTRUCTOR_P (decl)
7949           && verify_constructor_circularity (decl, decl))
7950         break;
7951 }
7952
7953 /* Attempt to create <clinit>. Pre-expand static fields so they can be
7954    safely used in some other methods/constructors.  */
7955
7956 static tree
7957 maybe_generate_pre_expand_clinit (tree class_type)
7958 {
7959   tree current, mdecl;
7960
7961   if (!TYPE_CLINIT_STMT_LIST (class_type))
7962     return NULL_TREE;
7963
7964   /* Go through all static fields and pre expand them */
7965   for (current = TYPE_FIELDS (class_type); current;
7966        current = TREE_CHAIN (current))
7967     if (FIELD_STATIC (current))
7968       build_field_ref (NULL_TREE, class_type, DECL_NAME (current));
7969
7970   /* Then build the <clinit> method */
7971   mdecl = create_artificial_method (class_type, ACC_STATIC, void_type_node,
7972                                     clinit_identifier_node, end_params_node);
7973   layout_class_method (class_type, CLASSTYPE_SUPER (class_type),
7974                        mdecl, NULL_TREE);
7975   start_artificial_method_body (mdecl);
7976
7977   /* We process the list of assignment we produced as the result of
7978      the declaration of initialized static field and add them as
7979      statement to the <clinit> method. */
7980   for (current = TYPE_CLINIT_STMT_LIST (class_type); current;
7981        current = TREE_CHAIN (current))
7982     {
7983       tree stmt = current;
7984       /* We build the assignment expression that will initialize the
7985          field to its value. There are strict rules on static
7986          initializers (8.5). FIXME */
7987       if (TREE_CODE (stmt) != BLOCK && !IS_EMPTY_STMT (stmt))
7988         stmt = build_debugable_stmt (EXPR_WFL_LINECOL (stmt), stmt);
7989       java_method_add_stmt (mdecl, stmt);
7990     }
7991
7992   end_artificial_method_body (mdecl);
7993
7994   /* Now we want to place <clinit> as the last method (because we need
7995      it at least for interface so that it doesn't interfere with the
7996      dispatch table based lookup. */
7997   if (TREE_CHAIN (TYPE_METHODS (class_type)))
7998     {
7999       current = TREE_CHAIN (TYPE_METHODS (class_type));
8000       TYPE_METHODS (class_type) = current;
8001
8002       while (TREE_CHAIN (current))
8003         current = TREE_CHAIN (current);
8004
8005       TREE_CHAIN (current) = mdecl;
8006       TREE_CHAIN (mdecl) = NULL_TREE;
8007     }
8008
8009   return mdecl;
8010 }
8011
8012 /* Analyzes a method body and look for something that isn't a
8013    MODIFY_EXPR with a constant value.  Return true if <clinit> is
8014    needed, false otherwise.  */
8015
8016 static int
8017 analyze_clinit_body (tree this_class, tree bbody)
8018 {
8019   while (bbody)
8020     switch (TREE_CODE (bbody))
8021       {
8022       case BLOCK:
8023         bbody = BLOCK_EXPR_BODY (bbody);
8024         break;
8025
8026       case EXPR_WITH_FILE_LOCATION:
8027         bbody = EXPR_WFL_NODE (bbody);
8028         break;
8029
8030       case COMPOUND_EXPR:
8031         if (analyze_clinit_body (this_class, TREE_OPERAND (bbody, 0)))
8032           return 1;
8033         bbody = TREE_OPERAND (bbody, 1);
8034         break;
8035
8036       case MODIFY_EXPR:
8037         /* If we're generating to class file and we're dealing with an
8038            array initialization, we return 1 to keep <clinit> */
8039         if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
8040             && flag_emit_class_files)
8041           return 1;
8042
8043         /* There are a few cases where we're required to keep
8044            <clinit>:
8045            - If this is an assignment whose operand is not constant,
8046            - If this is an assignment to a non-initialized field,
8047            - If this field is not a member of the current class.
8048         */
8049         return (! TREE_CONSTANT (TREE_OPERAND (bbody, 1))
8050                 || ! DECL_INITIAL (TREE_OPERAND (bbody, 0))
8051                 || DECL_CONTEXT (TREE_OPERAND (bbody, 0)) != this_class);
8052
8053       case NOP_EXPR:
8054         /* We might see an empty statement here, which is
8055            ignorable.  */
8056         return ! IS_EMPTY_STMT (bbody);
8057
8058       default:
8059         return 1;
8060       }
8061   return 0;
8062 }
8063
8064
8065 /* See whether we could get rid of <clinit>. Criteria are: all static
8066    final fields have constant initial values and the body of <clinit>
8067    is empty. Return 1 if <clinit> was discarded, 0 otherwise. */
8068
8069 static int
8070 maybe_yank_clinit (tree mdecl)
8071 {
8072   tree type, current;
8073   tree fbody, bbody;
8074
8075   if (!DECL_CLINIT_P (mdecl))
8076     return 0;
8077
8078   /* If the body isn't empty, then we keep <clinit>. Note that if
8079      we're emitting classfiles, this isn't enough not to rule it
8080      out. */
8081   fbody = DECL_FUNCTION_BODY (mdecl);
8082   bbody = BLOCK_EXPR_BODY (fbody);
8083   if (bbody && bbody != error_mark_node)
8084     bbody = BLOCK_EXPR_BODY (bbody);
8085   else
8086     return 0;
8087   if (bbody && ! flag_emit_class_files && !IS_EMPTY_STMT (bbody))
8088     return 0;
8089
8090   type = DECL_CONTEXT (mdecl);
8091   current = TYPE_FIELDS (type);
8092
8093   for (current = (current ? TREE_CHAIN (current) : current);
8094        current; current = TREE_CHAIN (current))
8095     {
8096       tree f_init;
8097
8098       /* We're not interested in non-static fields.  */
8099       if (!FIELD_STATIC (current))
8100         continue;
8101
8102       /* Nor in fields without initializers. */
8103       f_init = DECL_INITIAL (current);
8104       if (f_init == NULL_TREE)
8105         continue;
8106
8107       /* Anything that isn't String or a basic type is ruled out -- or
8108          if we know how to deal with it (when doing things natively) we
8109          should generated an empty <clinit> so that SUID are computed
8110          correctly. */
8111       if (! JSTRING_TYPE_P (TREE_TYPE (current))
8112           && ! JNUMERIC_TYPE_P (TREE_TYPE (current)))
8113         return 0;
8114
8115       if (! FIELD_FINAL (current) || ! TREE_CONSTANT (f_init))
8116         return 0;
8117     }
8118
8119   /* Now we analyze the method body and look for something that
8120      isn't a MODIFY_EXPR */
8121   if (bbody && !IS_EMPTY_STMT (bbody) && analyze_clinit_body (type, bbody))
8122     return 0;
8123
8124   /* Get rid of <clinit> in the class' list of methods */
8125   if (TYPE_METHODS (type) == mdecl)
8126     TYPE_METHODS (type) = TREE_CHAIN (mdecl);
8127   else
8128     for (current = TYPE_METHODS (type); current;
8129          current = TREE_CHAIN (current))
8130       if (TREE_CHAIN (current) == mdecl)
8131         {
8132           TREE_CHAIN (current) = TREE_CHAIN (mdecl);
8133           break;
8134         }
8135
8136   return 1;
8137 }
8138
8139 /* Install the argument from MDECL. Suitable to completion and
8140    expansion of mdecl's body.  */
8141
8142 void
8143 start_complete_expand_method (tree mdecl)
8144 {
8145   tree tem;
8146
8147   pushlevel (1);                /* Prepare for a parameter push */
8148   tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
8149   DECL_ARGUMENTS (mdecl) = tem;
8150
8151   for (; tem; tem = TREE_CHAIN (tem))
8152     {
8153       /* TREE_CHAIN (tem) will change after pushdecl. */
8154       tree next = TREE_CHAIN (tem);
8155       tree type = TREE_TYPE (tem);
8156       if (targetm.calls.promote_prototypes (type)
8157           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
8158           && INTEGRAL_TYPE_P (type))
8159         type = integer_type_node;
8160       DECL_ARG_TYPE (tem) = type;
8161       layout_decl (tem, 0);
8162       pushdecl (tem);
8163       /* Re-install the next so that the list is kept and the loop
8164          advances. */
8165       TREE_CHAIN (tem) = next;
8166     }
8167   pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8168   input_location = DECL_SOURCE_LOCATION (mdecl);
8169   build_result_decl (mdecl);
8170 }
8171
8172
8173 /* Complete and expand a method.  */
8174
8175 static void
8176 java_complete_expand_method (tree mdecl)
8177 {
8178   tree fbody, block_body, exception_copy;
8179
8180   current_function_decl = mdecl;
8181   /* Fix constructors before expanding them */
8182   if (DECL_CONSTRUCTOR_P (mdecl))
8183     fix_constructors (mdecl);
8184
8185   /* Expand functions that have a body */
8186   if (!DECL_FUNCTION_BODY (mdecl))
8187     return;
8188
8189   fbody = DECL_FUNCTION_BODY (mdecl);
8190   block_body = BLOCK_EXPR_BODY (fbody);
8191   exception_copy = NULL_TREE;
8192
8193   current_function_decl = mdecl;
8194
8195   if (! quiet_flag)
8196     fprintf (stderr, " [%s.",
8197              lang_printable_name (DECL_CONTEXT (mdecl), 0));
8198   announce_function (mdecl);
8199   if (! quiet_flag)
8200     fprintf (stderr, "]");
8201
8202   /* Prepare the function for tree completion */
8203   start_complete_expand_method (mdecl);
8204
8205   /* Install the current this */
8206   current_this = (!METHOD_STATIC (mdecl) ?
8207                   BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
8208
8209   /* Install exceptions thrown with `throws' */
8210   PUSH_EXCEPTIONS (DECL_FUNCTION_THROWS (mdecl));
8211
8212   if (block_body != NULL_TREE)
8213     {
8214       block_body = java_complete_tree (block_body);
8215
8216       /* Before we check initialization, attached all class initialization
8217          variable to the block_body */
8218       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (mdecl),
8219                      attach_init_test_initialization_flags, block_body);
8220
8221       if (! METHOD_NATIVE (mdecl))
8222         {
8223           check_for_initialization (block_body, mdecl);
8224
8225           /* Go through all the flags marking the initialization of
8226              static variables and see whether they're definitively
8227              assigned, in which case the type is remembered as
8228              definitively initialized in MDECL. */
8229           if (STATIC_CLASS_INIT_OPT_P ())
8230             {
8231               /* Always register the context as properly initialized in
8232                  MDECL. This used with caution helps removing extra
8233                  initialization of self. */
8234               if (METHOD_STATIC (mdecl))
8235                 {
8236                   *(htab_find_slot
8237                     (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (mdecl),
8238                      DECL_CONTEXT (mdecl), INSERT)) = DECL_CONTEXT (mdecl);
8239                 }
8240             }
8241         }
8242       ctxp->explicit_constructor_p = 0;
8243     }
8244
8245   BLOCK_EXPR_BODY (fbody) = block_body;
8246
8247   /* If we saw a return but couldn't evaluate it properly, we'll have
8248      an error_mark_node here. */
8249   if (block_body != error_mark_node
8250       && (block_body == NULL_TREE || CAN_COMPLETE_NORMALLY (block_body))
8251       && TREE_CODE (TREE_TYPE (TREE_TYPE (mdecl))) != VOID_TYPE)
8252     missing_return_error (current_function_decl);
8253
8254   /* See if we can get rid of <clinit> if MDECL happens to be <clinit> */
8255   maybe_yank_clinit (mdecl);
8256
8257   /* Pop the current level, with special measures if we found errors. */
8258   if (java_error_count)
8259     pushdecl_force_head (DECL_ARGUMENTS (mdecl));
8260   poplevel (1, 0, 1);
8261
8262   /* Pop the exceptions and sanity check */
8263   POP_EXCEPTIONS();
8264   if (currently_caught_type_list)
8265     abort ();
8266 }
8267
8268 /* For with each class for which there's code to generate. */
8269
8270 static void
8271 java_expand_method_bodies (tree class)
8272 {
8273   tree decl;
8274   for (decl = TYPE_METHODS (class); decl; decl = TREE_CHAIN (decl))
8275     {
8276       tree block;
8277
8278       if (! DECL_FUNCTION_BODY (decl))
8279         continue;
8280
8281       current_function_decl = decl;
8282
8283       block = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (decl));
8284
8285       /* Save the function body for gimplify and inlining.  */
8286       DECL_SAVED_TREE (decl) = block;
8287
8288       /* It's time to assign the variable flagging static class
8289          initialization based on which classes invoked static methods
8290          are definitely initializing. This should be flagged. */
8291       if (STATIC_CLASS_INIT_OPT_P ())
8292         {
8293           tree list = DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (decl);
8294           for (; list != NULL_TREE;  list = TREE_CHAIN (list))
8295             {
8296               /* Executed for each statement calling a static function.
8297                  LIST is a TREE_LIST whose PURPOSE is the called function
8298                  and VALUE is a compound whose second operand can be patched
8299                  with static class initialization flag assignments.  */
8300
8301               tree called_method = TREE_PURPOSE (list);
8302               tree compound = TREE_VALUE (list);
8303               tree assignment_compound_list
8304                 = build_tree_list (called_method, NULL);
8305
8306               /* For each class definitely initialized in
8307                  CALLED_METHOD, fill ASSIGNMENT_COMPOUND with
8308                  assignment to the class initialization flag. */
8309               htab_traverse (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (called_method),
8310                              emit_test_initialization,
8311                              assignment_compound_list);
8312
8313               if (TREE_VALUE (assignment_compound_list))
8314                 TREE_OPERAND (compound, 1)
8315                   = TREE_VALUE (assignment_compound_list);
8316             }
8317         }
8318
8319       /* Expand the function body.  */
8320       source_end_java_method ();
8321     }
8322 }
8323
8324 \f
8325
8326 /* This section of the code deals with accessing enclosing context
8327    fields either directly by using the relevant access to this$<n> or
8328    by invoking an access method crafted for that purpose.  */
8329
8330 /* Build the necessary access across nested class boundaries.
8331    This routine could be optimized to cache previous result
8332    (decl, current_class and returned access).  When an access method
8333    needs to be generated, it always takes the form of a read.  It might
8334    be later turned into a write by calling nested_field_access_fix.  */
8335
8336 static tree
8337 build_nested_field_access (tree id, tree decl)
8338 {
8339   tree access = NULL_TREE;
8340   tree ctx = NULL_TREE;
8341   tree decl_ctx = DECL_CONTEXT (decl);
8342   bool is_static = FIELD_STATIC (decl);
8343
8344   if (DECL_CONTEXT (TYPE_NAME (current_class)))
8345     ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
8346
8347   /* For non-static fields, if the immediate enclosing context of the
8348      current class is the field decl's class or inherits from it,
8349      build the access as `this$<n>.<field>'.  Note that we will break
8350      the `private' barrier if we're not emitting bytecodes.  */
8351   if (!is_static
8352       && ctx
8353       && (ctx == decl_ctx || inherits_from_p (ctx, decl_ctx))
8354       && (!FIELD_PRIVATE (decl) || !flag_emit_class_files))
8355     {
8356       tree thisn = build_current_thisn (current_class);
8357       access = make_qualified_primary (build_wfl_node (thisn),
8358                                        id, EXPR_WFL_LINECOL (id));
8359     }
8360   /* Otherwise, generate and use accessor methods for the field as
8361      needed.  */
8362   else
8363     {
8364       int lc = EXPR_WFL_LINECOL (id);
8365
8366       /* Now we chain the required number of calls to the access$0 to
8367          get a hold to the enclosing instance we need for a non-static
8368          field, and then we build the field access. */
8369       if (!is_static)
8370         access = build_access_to_thisn (current_class, decl_ctx, lc);
8371
8372       /* If the field is private and we're generating bytecode, then
8373          we generate an access method.  */
8374       if (FIELD_PRIVATE (decl) && flag_emit_class_files)
8375         {
8376           tree name = build_nested_field_access_methods (decl);
8377           access = build_nested_field_access_expr (lc, decl_ctx,
8378                                                    name, access, NULL_TREE);
8379         }
8380       /* Otherwise we use `access$(this$<j>). ... access$(this$<i>).<field>'
8381          for non-static fields.
8382          Once again we break the `private' access rule from a foreign
8383          class.  */
8384       else if (is_static)
8385         {
8386           tree class_name = DECL_NAME (TYPE_NAME (decl_ctx));
8387           access
8388             = make_qualified_primary (build_wfl_node (class_name), id, lc);
8389         }
8390       else
8391         access = make_qualified_primary (access, id, lc);
8392     }
8393
8394   return resolve_expression_name (access, NULL);
8395 }
8396
8397 /* Return a nonzero value if DECL describes a member access across nested
8398    class boundaries.  That is, DECL is in a class that either encloses,
8399    is enclosed by or shares a common enclosing class with the class
8400    TYPE.  */
8401
8402 static int
8403 nested_member_access_p (tree type, tree decl)
8404 {
8405   bool is_static = false;
8406   tree decl_type = DECL_CONTEXT (decl);
8407   tree type_root, decl_type_root;
8408
8409   if (decl_type == type
8410       || (TREE_CODE (decl) != FIELD_DECL
8411           && TREE_CODE (decl) != VAR_DECL
8412           && TREE_CODE (decl) != FUNCTION_DECL))
8413     return 0;
8414
8415   if (!INNER_CLASS_TYPE_P (type)
8416       && !(TREE_CODE (decl_type) == RECORD_TYPE
8417            && INNER_CLASS_TYPE_P (decl_type)))
8418     return 0;
8419
8420   is_static = (TREE_CODE (decl) == FUNCTION_DECL)
8421               ? METHOD_STATIC (decl)
8422               : FIELD_STATIC (decl);
8423
8424   /* If TYPE extends the declaration context of the non-static
8425      member we're trying to access, then this isn't a nested member
8426      access we need to worry about.  */
8427   if (!is_static && inherits_from_p (type, decl_type))
8428     return 0;
8429
8430   for (type_root = type;
8431        DECL_CONTEXT (TYPE_NAME (type_root));
8432        type_root = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type_root))))
8433     {
8434       if (type_root == decl_type)
8435         return 1;
8436     }
8437
8438   if (TREE_CODE (decl_type) == RECORD_TYPE
8439       && INNER_CLASS_TYPE_P (decl_type))
8440     {
8441       for (decl_type_root = decl_type;
8442            DECL_CONTEXT (TYPE_NAME (decl_type_root));
8443            decl_type_root
8444              = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (decl_type_root))))
8445         {
8446           if (decl_type_root == type)
8447             return 1;
8448         }
8449     }
8450   else
8451     decl_type_root = decl_type;
8452
8453   if (type_root == decl_type_root)
8454     return 1;
8455
8456   /* Before we give up, see whether it is a non-static field
8457      inherited from the enclosing context we are considering.  */
8458   if (!DECL_CONTEXT (TYPE_NAME (type_root))
8459       && !is_static
8460       && inherits_from_p (type_root, decl_type))
8461     return 1;
8462
8463   return 0;
8464 }
8465
8466 /* Return a nonzero value if NODE represents a cross-nested-class
8467    access that has already been expanded.  As a side effect, it returns
8468    the name of the field being accessed and the argument passed to the
8469    access function, suitable for a regeneration of the access method
8470    call if necessary.  */
8471
8472 static int
8473 nested_field_expanded_access_p (tree node, tree *name, tree *arg_type,
8474                                 tree *arg)
8475 {
8476   int identified = 0;
8477
8478   if (TREE_CODE (node) != CALL_EXPR)
8479     return 0;
8480
8481   /* Well, GCJ generates slightly different tree nodes when compiling
8482      to native or bytecodes.  It's the case for function calls.  */
8483
8484   if (flag_emit_class_files
8485       && TREE_CODE (node) == CALL_EXPR
8486       && NESTED_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (TREE_OPERAND (node, 0))))
8487     identified = 1;
8488   else if (!flag_emit_class_files)
8489     {
8490       node = TREE_OPERAND (node, 0);
8491
8492       if (node && TREE_OPERAND (node, 0)
8493           && TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)
8494         {
8495           node = TREE_OPERAND (node, 0);
8496           if (TREE_OPERAND (node, 0)
8497               && TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
8498               && (NESTED_FIELD_ACCESS_IDENTIFIER_P
8499                   (DECL_NAME (TREE_OPERAND (node, 0)))))
8500             identified = 1;
8501         }
8502     }
8503
8504   if (identified && name && arg_type && arg)
8505     {
8506       tree argument = TREE_OPERAND (node, 1);
8507       *name = DECL_NAME (TREE_OPERAND (node, 0));
8508
8509       /* The accessors for static fields do not take in a this$<n> argument,
8510          so we take the class name from the accessor's context instead.  */
8511       if (argument)
8512         {
8513           *arg_type = TREE_TYPE (TREE_TYPE (TREE_VALUE (argument)));
8514           *arg = TREE_VALUE (argument);
8515         }
8516       else
8517         {
8518           *arg_type = DECL_CONTEXT (TREE_OPERAND (node, 0));
8519           *arg = NULL_TREE;
8520         }
8521     }
8522   return identified;
8523 }
8524
8525 /* Detect in NODE cross-nested-class field read access and
8526    transform it into a write with RHS as an argument.  This function
8527    is called from the java_complete_lhs when an assignment to a LHS can
8528    be identified.  */
8529
8530 static tree
8531 nested_field_access_fix (tree wfl, tree node, tree rhs)
8532 {
8533   tree name, arg_type, arg;
8534
8535   if (nested_field_expanded_access_p (node, &name, &arg_type, &arg))
8536     {
8537       node = build_nested_field_access_expr (EXPR_WFL_LINECOL (wfl),
8538                                              arg_type, name, arg, rhs);
8539       return java_complete_tree (node);
8540     }
8541   return NULL_TREE;
8542 }
8543
8544 /* Construct the expression that calls an access method:
8545      <type>.access$<n>(<arg1> [, <arg2>]);
8546
8547    ARG2 can be NULL and will be omitted in that case. It will denote a
8548    read access.  */
8549
8550 static tree
8551 build_nested_field_access_expr (int lc, tree type, tree access_method_name,
8552                                 tree arg1, tree arg2)
8553 {
8554   tree args, cn, access;
8555
8556   if (arg1)
8557     args = build_tree_list (NULL_TREE, arg1);
8558   else
8559     args = NULL_TREE;
8560
8561   if (arg2)
8562     {
8563       if (args)
8564         args = tree_cons (NULL_TREE, arg2, args);
8565       else
8566         args = build_tree_list (NULL_TREE, arg2);
8567     }
8568
8569   access
8570     = build_method_invocation (build_wfl_node (access_method_name), args);
8571   cn = build_wfl_node (DECL_NAME (TYPE_NAME (type)));
8572
8573   return make_qualified_primary (cn, access, lc);
8574 }
8575
8576 /* Build the name of a synthetic accessor used to access class members
8577    across nested class boundaries.  */
8578
8579 static tree
8580 build_new_access_id (void)
8581 {
8582   static int access_n_counter = 1;
8583   char buffer [128];
8584
8585   sprintf (buffer, "access$%d", access_n_counter++);
8586   return get_identifier (buffer);
8587 }
8588
8589 /* Create the static access functions for the cross-nested-class field DECL.
8590    We define a read:
8591      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$) {
8592        return inst$.field;
8593      }
8594    and a write access:
8595      TREE_TYPE (<field>) access$<n> (DECL_CONTEXT (<field>) inst$,
8596                                      TREE_TYPE (<field>) value$) {
8597        return inst$.field = value$;
8598      }
8599    For static fields, these methods are generated without the instance
8600    parameter.
8601    We should have a usage flag on the DECL so we can lazily turn the ones
8602    we're using for code generation.  FIXME.
8603 */
8604
8605 static tree
8606 build_nested_field_access_methods (tree decl)
8607 {
8608   tree id, args, stmt, mdecl, class_name = NULL_TREE;
8609   bool is_static = FIELD_STATIC (decl);
8610
8611   if (FIELD_NESTED_ACCESS_P (decl))
8612     return FIELD_NESTED_ACCESS (decl);
8613
8614   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
8615
8616   /* Create the identifier and a function named after it.  */
8617   id = build_new_access_id ();
8618
8619   /* The identifier is marked as bearing the name of a generated write
8620      access function for outer field accessed from inner classes.  */
8621   NESTED_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8622
8623   /* Create the read access.  */
8624   if (!is_static)
8625     {
8626       args = build_tree_list (inst_id,
8627                               build_pointer_type (DECL_CONTEXT (decl)));
8628       TREE_CHAIN (args) = end_params_node;
8629       stmt = make_qualified_primary (build_wfl_node (inst_id),
8630                                      build_wfl_node (DECL_NAME (decl)), 0);
8631     }
8632   else
8633     {
8634       args = end_params_node;
8635       class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)));
8636       stmt = make_qualified_primary (build_wfl_node (class_name),
8637                                      build_wfl_node (DECL_NAME (decl)), 0);
8638     }
8639   stmt = build_return (0, stmt);
8640   mdecl = build_nested_field_access_method (DECL_CONTEXT (decl),
8641                                             TREE_TYPE (decl), id, args, stmt);
8642   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8643
8644   /* Create the write access method.  No write access for final variable */
8645   if (!FIELD_FINAL (decl))
8646     {
8647       if (!is_static)
8648         {
8649           args = build_tree_list (inst_id,
8650                                   build_pointer_type (DECL_CONTEXT (decl)));
8651           TREE_CHAIN (args) = build_tree_list (wpv_id, TREE_TYPE (decl));
8652           TREE_CHAIN (TREE_CHAIN (args)) = end_params_node;
8653           stmt = make_qualified_primary (build_wfl_node (inst_id),
8654                                          build_wfl_node (DECL_NAME (decl)),
8655                                          0);
8656         }
8657       else
8658         {
8659           args = build_tree_list (wpv_id, TREE_TYPE (decl));
8660           TREE_CHAIN (args) = end_params_node;
8661           stmt = make_qualified_primary (build_wfl_node (class_name),
8662                                          build_wfl_node (DECL_NAME (decl)),
8663                                          0);
8664         }
8665       stmt = build_return (0, build_assignment (ASSIGN_TK, 0, stmt,
8666                                                 build_wfl_node (wpv_id)));
8667       mdecl = build_nested_field_access_method (DECL_CONTEXT (decl),
8668                                                 TREE_TYPE (decl), id,
8669                                                 args, stmt);
8670     }
8671   DECL_FUNCTION_ACCESS_DECL (mdecl) = decl;
8672
8673   /* Return the access name */
8674   return FIELD_NESTED_ACCESS (decl) = id;
8675 }
8676
8677 /* Build a field access method NAME.  */
8678
8679 static tree
8680 build_nested_field_access_method (tree class, tree type, tree name,
8681                                   tree args, tree body)
8682 {
8683   tree saved_current_function_decl, mdecl;
8684
8685   /* Create the method */
8686   mdecl = create_artificial_method (class, ACC_STATIC, type, name, args);
8687   fix_method_argument_names (args, mdecl);
8688   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8689
8690   /* Attach the method body. */
8691   saved_current_function_decl = current_function_decl;
8692   start_artificial_method_body (mdecl);
8693   java_method_add_stmt (mdecl, body);
8694   end_artificial_method_body (mdecl);
8695   current_function_decl = saved_current_function_decl;
8696
8697   return mdecl;
8698 }
8699
8700 \f
8701 /* This section deals with building access function necessary for
8702    certain kinds of method invocation across nested class boundaries.  */
8703
8704 static tree
8705 build_nested_method_access_method (tree decl)
8706 {
8707   tree saved_current_function_decl, mdecl;
8708   tree args = NULL_TREE, call_args = NULL_TREE;
8709   tree carg, id, body, class;
8710   char buffer [80];
8711   int parm_id_count = 0;
8712
8713   /* Test this abort with an access to a private field */
8714   if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "access$"))
8715     abort ();
8716
8717   /* Check the cache first */
8718   if (DECL_FUNCTION_INNER_ACCESS (decl))
8719     return DECL_FUNCTION_INNER_ACCESS (decl);
8720
8721   class = DECL_CONTEXT (decl);
8722
8723   /* Obtain an access identifier and mark it */
8724   id = build_new_access_id ();
8725   NESTED_FIELD_ACCESS_IDENTIFIER_P (id) = 1;
8726
8727   carg = TYPE_ARG_TYPES (TREE_TYPE (decl));
8728   /* Create the arguments, as much as the original */
8729   for (; carg && carg != end_params_node;
8730        carg = TREE_CHAIN (carg))
8731     {
8732       sprintf (buffer, "write_parm_value$%d", parm_id_count++);
8733       args = chainon (args, build_tree_list (get_identifier (buffer),
8734                                              TREE_VALUE (carg)));
8735     }
8736   args = chainon (args, end_params_node);
8737
8738   /* Create the method */
8739   mdecl = create_artificial_method (class, ACC_STATIC,
8740                                     TREE_TYPE (TREE_TYPE (decl)), id, args);
8741   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
8742   /* There is a potential bug here. We should be able to use
8743      fix_method_argument_names, but then arg names get mixed up and
8744      eventually a constructor will have its this$0 altered and the
8745      outer context won't be assignment properly. The testcase is
8746      stub.java FIXME */
8747   TYPE_ARG_TYPES (TREE_TYPE (mdecl)) = args;
8748
8749   /* Attach the method body. */
8750   saved_current_function_decl = current_function_decl;
8751   start_artificial_method_body (mdecl);
8752
8753   /* The actual method invocation uses the same args. When invoking a
8754      static methods that way, we don't want to skip the first argument.  */
8755   carg = args;
8756   if (!METHOD_STATIC (decl))
8757     carg = TREE_CHAIN (carg);
8758   for (; carg && carg != end_params_node; carg = TREE_CHAIN (carg))
8759     call_args = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (carg)),
8760                            call_args);
8761
8762   body = build_method_invocation (build_wfl_node (DECL_NAME (decl)),
8763                                   call_args);
8764   if (!METHOD_STATIC (decl))
8765     body = make_qualified_primary (build_wfl_node (TREE_PURPOSE (args)),
8766                                    body, 0);
8767   if (TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
8768     body = build_return (0, body);
8769   java_method_add_stmt (mdecl,body);
8770   end_artificial_method_body (mdecl);
8771   current_function_decl = saved_current_function_decl;
8772
8773   /* Back tag the access function so it know what it accesses.  */
8774   DECL_FUNCTION_ACCESS_DECL (decl) = mdecl;
8775
8776   /* Tag the current method so it knows it has an access generated.  */
8777   return DECL_FUNCTION_INNER_ACCESS (decl) = mdecl;
8778 }
8779
8780 \f
8781 /* This section of the code deals with building expressions to access
8782    the enclosing instance of an inner class. The enclosing instance is
8783    kept in a generated field called this$<n>, with <n> being the
8784    inner class nesting level (starting from 0.)  */
8785
8786 /* Build an access to a given this$<n>, always chaining access call to
8787    others. Access methods to this$<n> are build on the fly if
8788    necessary. This CAN'T be used to solely access this$<n-1> from
8789    this$<n> (which alway yield to special cases and optimization, see
8790    for example build_nested_field_access).  */
8791
8792 static tree
8793 build_access_to_thisn (tree from, tree to, int lc)
8794 {
8795   tree access = NULL_TREE;
8796
8797   while (from != to && PURE_INNER_CLASS_TYPE_P (from))
8798     {
8799       if (!access)
8800         {
8801           access = build_current_thisn (from);
8802           access = build_wfl_node (access);
8803         }
8804       else
8805         {
8806           tree access0_wfl, cn;
8807
8808           maybe_build_thisn_access_method (from);
8809           access0_wfl = build_wfl_node (access0_identifier_node);
8810           cn = build_wfl_node (DECL_NAME (TYPE_NAME (from)));
8811           EXPR_WFL_LINECOL (access0_wfl) = lc;
8812           access = build_tree_list (NULL_TREE, access);
8813           access = build_method_invocation (access0_wfl, access);
8814           access = make_qualified_primary (cn, access, lc);
8815         }
8816
8817       /* If FROM isn't an inner class, that's fine, we've done enough.
8818          What we're looking for can be accessed from there.  */
8819       from = DECL_CONTEXT (TYPE_NAME (from));
8820       if (!from)
8821         break;
8822       from = TREE_TYPE (from);
8823     }
8824   return access;
8825 }
8826
8827 /* Build an access function to the this$<n> local to TYPE. NULL_TREE
8828    is returned if nothing needs to be generated. Otherwise, the method
8829    generated and a method decl is returned.
8830
8831    NOTE: These generated methods should be declared in a class file
8832    attribute so that they can't be referred to directly.  */
8833
8834 static tree
8835 maybe_build_thisn_access_method (tree type)
8836 {
8837   tree mdecl, args, stmt, rtype;
8838   tree saved_current_function_decl;
8839
8840   /* If TYPE is a top-level class, no access method is required.
8841      If there already is such an access method, bail out. */
8842   if (CLASS_ACCESS0_GENERATED_P (type) || !PURE_INNER_CLASS_TYPE_P (type))
8843     return NULL_TREE;
8844
8845   /* We generate the method. The method looks like:
8846      static <outer_of_type> access$0 (<type> inst$) { return inst$.this$<n>; }
8847   */
8848   args = build_tree_list (inst_id, build_pointer_type (type));
8849   TREE_CHAIN (args) = end_params_node;
8850   rtype = build_pointer_type (TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))));
8851   mdecl = create_artificial_method (type, ACC_STATIC, rtype,
8852                                     access0_identifier_node, args);
8853   fix_method_argument_names (args, mdecl);
8854   layout_class_method (type, NULL_TREE, mdecl, NULL_TREE);
8855   stmt = build_current_thisn (type);
8856   stmt = make_qualified_primary (build_wfl_node (inst_id),
8857                                  build_wfl_node (stmt), 0);
8858   stmt = build_return (0, stmt);
8859
8860   saved_current_function_decl = current_function_decl;
8861   start_artificial_method_body (mdecl);
8862   java_method_add_stmt (mdecl, stmt);
8863   end_artificial_method_body (mdecl);
8864   current_function_decl = saved_current_function_decl;
8865
8866   CLASS_ACCESS0_GENERATED_P (type) = 1;
8867
8868   return mdecl;
8869 }
8870
8871 /* Craft an correctly numbered `this$<n>'string. this$0 is used for
8872    the first level of innerclassing. this$1 for the next one, etc...
8873    This function can be invoked with TYPE to NULL, available and then
8874    has to count the parser context.  */
8875
8876 static GTY(()) tree saved_thisn;
8877 static GTY(()) tree saved_type;
8878
8879 static tree
8880 build_current_thisn (tree type)
8881 {
8882   static int saved_i = -1;
8883   static int saved_type_i = 0;
8884   tree decl;
8885   char buffer [24];
8886   int i = 0;
8887
8888   if (type)
8889     {
8890       if (type == saved_type)
8891         i = saved_type_i;
8892       else
8893         {
8894           for (i = -1, decl = DECL_CONTEXT (TYPE_NAME (type));
8895                decl; decl = DECL_CONTEXT (decl), i++)
8896             ;
8897
8898           saved_type = type;
8899           saved_type_i = i;
8900         }
8901     }
8902   else
8903     i = list_length (GET_CPC_LIST ())-2;
8904
8905   if (i == saved_i)
8906     return saved_thisn;
8907
8908   sprintf (buffer, "this$%d", i);
8909   saved_i = i;
8910   saved_thisn = get_identifier (buffer);
8911   return saved_thisn;
8912 }
8913
8914 /* Return the assignment to the hidden enclosing context `this$<n>'
8915    by the second incoming parameter to the innerclass constructor. The
8916    form used is `this.this$<n> = this$<n>;'.  */
8917
8918 static tree
8919 build_thisn_assign (void)
8920 {
8921   if (current_class && PURE_INNER_CLASS_TYPE_P (current_class))
8922     {
8923       tree thisn = build_current_thisn (current_class);
8924       tree lhs = make_qualified_primary (build_wfl_node (this_identifier_node),
8925                                          build_wfl_node (thisn), 0);
8926       tree rhs = build_wfl_node (thisn);
8927 #ifdef USE_MAPPED_LOCATION
8928       SET_EXPR_LOCATION (lhs, input_location);
8929 #else
8930       EXPR_WFL_SET_LINECOL (lhs, input_line, 0);
8931 #endif
8932       return build_assignment (ASSIGN_TK, EXPR_WFL_LINECOL (lhs), lhs, rhs);
8933     }
8934   return NULL_TREE;
8935 }
8936
8937 \f
8938 /* Building the synthetic `class$' used to implement the `.class' 1.1
8939    extension for non primitive types. This method looks like:
8940
8941     static Class class$(String type) throws NoClassDefFoundError
8942     {
8943       try {return (java.lang.Class.forName (String));}
8944       catch (ClassNotFoundException e) {
8945         throw new NoClassDefFoundError(e.getMessage());}
8946     } */
8947
8948 static GTY(()) tree get_message_wfl;
8949 static GTY(()) tree type_parm_wfl;
8950
8951 static tree
8952 build_dot_class_method (tree class)
8953 {
8954 #define BWF(S) build_wfl_node (get_identifier ((S)))
8955 #ifdef USE_MAPPED_LOCATION
8956 #define MQN(X,Y) make_qualified_name ((X), (Y), UNKNOWN_LOCATION)
8957 #else
8958 #define MQN(X,Y) make_qualified_name ((X), (Y), 0)
8959 #endif
8960   tree args, tmp, saved_current_function_decl, mdecl, qual_name;
8961   tree stmt, throw_stmt;
8962
8963   if (!get_message_wfl)
8964     {
8965       get_message_wfl = build_wfl_node (get_identifier ("getMessage"));
8966       type_parm_wfl = build_wfl_node (get_identifier ("type$"));
8967     }
8968
8969   /* Build the arguments */
8970   args = build_tree_list (get_identifier ("type$"),
8971                           build_pointer_type (string_type_node));
8972   TREE_CHAIN (args) = end_params_node;
8973
8974   /* Build the qualified name java.lang.Class.forName */
8975   tmp = MQN (MQN (MQN (BWF ("java"),
8976                        BWF ("lang")), BWF ("Class")), BWF ("forName"));
8977
8978   /* Create the "class$" function */
8979   mdecl = create_artificial_method (class, ACC_STATIC,
8980                                     build_pointer_type (class_type_node),
8981                                     classdollar_identifier_node, args);
8982   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
8983                    BWF ("NoClassDefFoundError"));
8984   DECL_FUNCTION_THROWS (mdecl) = build_tree_list (NULL_TREE, qual_name);
8985   register_incomplete_type (JDEP_EXCEPTION, qual_name, NULL_TREE, NULL_TREE);
8986   JDEP_GET_PATCH (CLASSD_LAST (ctxp->classd_list)) =
8987     &TREE_VALUE (DECL_FUNCTION_THROWS (mdecl));
8988
8989   /* We start by building the try block. We need to build:
8990        return (java.lang.Class.forName (type)); */
8991   stmt = build_method_invocation (tmp,
8992                                   build_tree_list (NULL_TREE, type_parm_wfl));
8993   stmt = build_return (0, stmt);
8994
8995   /* Now onto the catch block. We start by building the expression
8996      throwing a new exception: throw new NoClassDefFoundError (_.getMessage) */
8997 #ifdef USE_MAPPED_LOCATION
8998   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
8999                                     get_message_wfl, UNKNOWN_LOCATION);
9000 #else
9001   throw_stmt = make_qualified_name (build_wfl_node (wpv_id),
9002                                     get_message_wfl, 0);
9003 #endif
9004   throw_stmt = build_method_invocation (throw_stmt, NULL_TREE);
9005
9006   /* Build new NoClassDefFoundError (_.getMessage) */
9007   throw_stmt = build_new_invocation
9008     (build_wfl_node (get_identifier ("NoClassDefFoundError")),
9009      build_tree_list (build_pointer_type (string_type_node), throw_stmt));
9010
9011   /* Build the throw, (it's too early to use BUILD_THROW) */
9012   throw_stmt = build1 (THROW_EXPR, NULL_TREE, throw_stmt);
9013
9014   /* Encapsulate STMT in a try block. The catch clause executes THROW_STMT */
9015   qual_name = MQN (MQN (BWF ("java"), BWF ("lang")),
9016                    BWF ("ClassNotFoundException"));
9017   stmt = encapsulate_with_try_catch (0, qual_name, stmt, throw_stmt);
9018
9019   fix_method_argument_names (args, mdecl);
9020   layout_class_method (class, NULL_TREE, mdecl, NULL_TREE);
9021   saved_current_function_decl = current_function_decl;
9022   start_artificial_method_body (mdecl);
9023   java_method_add_stmt (mdecl, stmt);
9024   end_artificial_method_body (mdecl);
9025   current_function_decl = saved_current_function_decl;
9026   TYPE_DOT_CLASS (class) = mdecl;
9027
9028   return mdecl;
9029 }
9030
9031 static tree
9032 build_dot_class_method_invocation (tree this_class, tree type)
9033 {
9034   tree dot_class_method = TYPE_DOT_CLASS (this_class);
9035   tree sig_id, s, t;
9036
9037   if (TYPE_ARRAY_P (type))
9038     sig_id = build_java_signature (type);
9039   else
9040     sig_id = DECL_NAME (TYPE_NAME (type));
9041
9042   /* Ensure that the proper name separator is used */
9043   sig_id = unmangle_classname (IDENTIFIER_POINTER (sig_id),
9044                                IDENTIFIER_LENGTH (sig_id));
9045
9046   s = build_string (IDENTIFIER_LENGTH (sig_id),
9047                     IDENTIFIER_POINTER (sig_id));
9048   t = build_method_invocation (build_wfl_node (DECL_NAME (dot_class_method)),
9049                                build_tree_list (NULL_TREE, s));
9050   if (DECL_CONTEXT (dot_class_method) != this_class)
9051     {
9052       tree class_name = DECL_NAME (TYPE_NAME (DECL_CONTEXT (dot_class_method)));
9053       t = make_qualified_primary (build_wfl_node (class_name), t, 0);
9054     }
9055   return t;
9056 }
9057
9058 /* This section of the code deals with constructor.  */
9059
9060 /* Craft a body for default constructor. Patch existing constructor
9061    bodies with call to super() and field initialization statements if
9062    necessary.  */
9063
9064 static void
9065 fix_constructors (tree mdecl)
9066 {
9067   tree iii;                     /* Instance Initializer Invocation */
9068   tree *bodyp = &DECL_FUNCTION_BODY (mdecl);
9069   tree thisn_assign, compound = NULL_TREE;
9070   tree class_type = DECL_CONTEXT (mdecl);
9071
9072   if (DECL_FIXED_CONSTRUCTOR_P (mdecl))
9073     return;
9074   DECL_FIXED_CONSTRUCTOR_P (mdecl) = 1;
9075
9076   if (!*bodyp)
9077     {
9078       /* It is an error for the compiler to generate a default
9079          constructor if the superclass doesn't have a constructor that
9080          takes no argument, or the same args for an anonymous class */
9081       tree sdecl = get_constructor_super (mdecl);
9082       if (sdecl == NULL_TREE)
9083         {
9084           tree sclass_decl = TYPE_NAME (CLASSTYPE_SUPER (class_type));
9085           tree save = DECL_NAME (mdecl);
9086           const char *n = IDENTIFIER_POINTER (DECL_NAME (sclass_decl));
9087           DECL_NAME (mdecl) = DECL_NAME (sclass_decl);
9088           parse_error_context
9089             (lookup_cl (TYPE_NAME (class_type)),
9090              "No constructor matching %qs found in class %qs",
9091              lang_printable_name (mdecl, 2), n);
9092           DECL_NAME (mdecl) = save;
9093         }
9094
9095       if (ANONYMOUS_CLASS_P (class_type))
9096         {
9097           /* Copy throws clause from the super constructor.  */
9098           tree throws = DECL_FUNCTION_THROWS (sdecl);
9099           DECL_FUNCTION_THROWS (mdecl) = copy_list (throws);
9100         }
9101
9102       /* The constructor body must be crafted by hand. It's the
9103          constructor we defined when we realize we didn't have the
9104          CLASSNAME() constructor */
9105       start_artificial_method_body (mdecl);
9106
9107       /* Insert an assignment to the this$<n> hidden field, if
9108          necessary */
9109       if ((thisn_assign = build_thisn_assign ()))
9110         java_method_add_stmt (mdecl, thisn_assign);
9111
9112       /* We don't generate a super constructor invocation if we're
9113          compiling java.lang.Object. build_super_invocation takes care
9114          of that. */
9115       java_method_add_stmt (mdecl, build_super_invocation (mdecl));
9116
9117       /* FIXME */
9118       if ((iii = build_instinit_invocation (class_type)))
9119         java_method_add_stmt (mdecl, iii);
9120
9121       end_artificial_method_body (mdecl);
9122     }
9123   /* Search for an explicit constructor invocation */
9124   else
9125     {
9126       int found = 0;
9127       int invokes_this = 0;
9128       tree main_block = BLOCK_EXPR_BODY (*bodyp);
9129
9130       while (*bodyp)
9131         {
9132           tree body = *bodyp;
9133           switch (TREE_CODE (body))
9134             {
9135             case CALL_EXPR:
9136               found = CALL_EXPLICIT_CONSTRUCTOR_P (body);
9137               if (CALL_THIS_CONSTRUCTOR_P (body))
9138                 invokes_this = 1;
9139               break;
9140             case COMPOUND_EXPR:
9141             case EXPR_WITH_FILE_LOCATION:
9142               bodyp = &TREE_OPERAND (body, 0);
9143               continue;
9144             case BLOCK:
9145               bodyp = &BLOCK_EXPR_BODY (body);
9146               continue;
9147             default:
9148               break;
9149             }
9150           break;
9151         }
9152
9153       /* Generate the assignment to this$<n>, if necessary */
9154       if ((thisn_assign = build_thisn_assign ()))
9155         compound = add_stmt_to_compound (compound, NULL_TREE, thisn_assign);
9156
9157       /* The constructor is missing an invocation of super() */
9158       if (!found)
9159         compound = add_stmt_to_compound (compound, NULL_TREE,
9160                                          build_super_invocation (mdecl));
9161       /* Explicit super() invocation should take place before the
9162          instance initializer blocks. */
9163       else
9164         {
9165           compound = add_stmt_to_compound (compound, NULL_TREE, *bodyp);
9166           *bodyp = build_java_empty_stmt ();
9167         }
9168
9169       DECL_INIT_CALLS_THIS (mdecl) = invokes_this;
9170
9171       /* Insert the instance initializer block right after. */
9172       if (!invokes_this && (iii = build_instinit_invocation (class_type)))
9173         compound = add_stmt_to_compound (compound, NULL_TREE, iii);
9174
9175       /* Fix the constructor main block if we're adding extra stmts */
9176       if (compound)
9177         {
9178           compound = add_stmt_to_compound (compound, NULL_TREE,
9179                                            BLOCK_EXPR_BODY (main_block));
9180           BLOCK_EXPR_BODY (main_block) = compound;
9181         }
9182     }
9183 }
9184
9185 /* Browse constructors in the super class, searching for a constructor
9186    that doesn't take any argument. Return the constructor if one is found,
9187    NULL_TREE otherwise.  If the current class is an anonymous inner class,
9188    look for something that has the same signature. */
9189 static tree
9190 get_constructor_super (tree mdecl)
9191 {
9192   tree class = CLASSTYPE_SUPER (current_class);
9193   int super_inner = PURE_INNER_CLASS_TYPE_P (class);
9194   tree sdecl;
9195
9196   if (!class)
9197     return NULL_TREE;
9198
9199   if (ANONYMOUS_CLASS_P (current_class))
9200     {
9201       tree mdecl_arg_type;
9202       SKIP_THIS_AND_ARTIFICIAL_PARMS (mdecl_arg_type, mdecl);
9203       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
9204         if (DECL_CONSTRUCTOR_P (sdecl))
9205           {
9206             tree m_arg_type;
9207             tree arg_type = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
9208             if (super_inner)
9209               arg_type = TREE_CHAIN (arg_type);
9210             for (m_arg_type = mdecl_arg_type;
9211                  (arg_type != end_params_node
9212                   && m_arg_type != end_params_node);
9213                  arg_type = TREE_CHAIN (arg_type),
9214                    m_arg_type = TREE_CHAIN (m_arg_type))
9215               if (!valid_method_invocation_conversion_p
9216                      (TREE_VALUE (arg_type),
9217                       TREE_VALUE (m_arg_type)))
9218                 break;
9219
9220             if (arg_type == end_params_node && m_arg_type == end_params_node)
9221               return sdecl;
9222           }
9223     }
9224   else
9225     {
9226       for (sdecl = TYPE_METHODS (class); sdecl; sdecl = TREE_CHAIN (sdecl))
9227         {
9228           tree arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (sdecl)));
9229           if (super_inner)
9230             arg = TREE_CHAIN (arg);
9231           if (DECL_CONSTRUCTOR_P (sdecl) && arg == end_params_node)
9232             return sdecl;
9233         }
9234     }
9235   return NULL_TREE;
9236 }
9237
9238 /* Generate code for all context remembered for code generation.  */
9239
9240 static GTY(()) tree reversed_class_list;
9241 void
9242 java_expand_classes (void)
9243 {
9244   int save_error_count = 0;
9245   static struct parser_ctxt *cur_ctxp = NULL;
9246   location_t save_location;
9247
9248   java_parse_abort_on_error ();
9249   if (!(ctxp = ctxp_for_generation))
9250     return;
9251   java_layout_classes ();
9252   java_parse_abort_on_error ();
9253   save_location = input_location;
9254
9255   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9256     {
9257       tree current;
9258       for (current = cur_ctxp->class_list;
9259            current;
9260            current = TREE_CHAIN (current))
9261         gen_indirect_dispatch_tables (TREE_TYPE (current));
9262     }
9263
9264   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9265     {
9266       ctxp = cur_ctxp;
9267       input_location = ctxp->file_start_location;
9268       lang_init_source (2);            /* Error msgs have method prototypes */
9269       java_complete_expand_classes (); /* Complete and expand classes */
9270       java_parse_abort_on_error ();
9271     }
9272   input_location = save_location;
9273
9274   /* Find anonymous classes and expand their constructor. This extra pass is
9275      necessary because the constructor itself is only generated when the
9276      method in which it is defined is expanded. */
9277   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9278     {
9279       tree current;
9280       ctxp = cur_ctxp;
9281       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9282         {
9283           output_class = current_class = TREE_TYPE (current);
9284           if (ANONYMOUS_CLASS_P (current_class))
9285             {
9286               tree d;
9287               for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9288                 {
9289                   if (DECL_CONSTRUCTOR_P (d))
9290                     {
9291                       java_complete_expand_method (d);
9292                       break;    /* There is only one constructor. */
9293                     }
9294                 }
9295             }
9296         }
9297     }
9298
9299   /* Expanding the constructors of anonymous classes generates access
9300      methods.  Scan all the methods looking for null DECL_RESULTs --
9301      this will be the case if a method hasn't been expanded.  */
9302   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9303     {
9304       tree current;
9305       ctxp = cur_ctxp;
9306       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9307         {
9308           tree d;
9309           output_class = current_class = TREE_TYPE (current);
9310           for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9311             {
9312               if (DECL_RESULT (d) == NULL_TREE)
9313                 java_complete_expand_method (d);
9314             }
9315         }
9316     }
9317
9318   /* ???  Instead of all this we could iterate around the list of
9319      classes until there were no more un-expanded methods.  It would
9320      take a little longer -- one pass over the whole list of methods
9321      -- but it would be simpler.  Like this:  */
9322 #if 0
9323     {
9324       int something_changed;
9325
9326       do
9327         {
9328           something_changed = 0;
9329           for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9330             {
9331               tree current;
9332               ctxp = cur_ctxp;
9333               for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9334                 {
9335                   tree d;
9336                   output_class = current_class = TREE_TYPE (current);
9337                   for (d = TYPE_METHODS (current_class); d; d = TREE_CHAIN (d))
9338                     {
9339                       if (DECL_RESULT (d) == NULL_TREE)
9340                         {
9341                           something_changed = 1;
9342                           java_complete_expand_method (d);
9343                         }
9344                     }
9345                 }
9346             }
9347         }
9348       while (something_changed);
9349     }
9350 #endif
9351
9352   /* If we've found error at that stage, don't try to generate
9353      anything, unless we're checking the syntax only
9354      (but not using -fsyntax-only for the purpose of generating
9355      bytecode).  */
9356   if (java_error_count
9357       && (!flag_syntax_only && !flag_emit_class_files))
9358     return;
9359
9360   /* Now things are stable, go for generation of the class data. */
9361
9362   /* We pessimistically marked all methods and fields external until
9363      we knew what set of classes we were planning to compile.  Now mark
9364      those that will be generated locally as not external.  */
9365   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9366     {
9367       tree current;
9368       ctxp = cur_ctxp;
9369       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9370         java_mark_class_local (TREE_TYPE (current));
9371     }
9372
9373   /* Compile the classes.  */
9374   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9375     {
9376       tree current;
9377       reversed_class_list = NULL;
9378
9379       ctxp = cur_ctxp;
9380
9381       /* We write out the classes in reverse order.  This ensures that
9382          inner classes are written before their containing classes,
9383          which is important for parallel builds.  Otherwise, the
9384          class file for the outer class may be found, but the class
9385          file for the inner class may not be present.  In that
9386          situation, the compiler cannot fall back to the original
9387          source, having already read the outer class, so we must
9388          prevent that situation.  */
9389       for (current = ctxp->class_list;
9390            current;
9391            current = TREE_CHAIN (current))
9392         reversed_class_list
9393           = tree_cons (NULL_TREE, current, reversed_class_list);
9394
9395       for (current = reversed_class_list;
9396            current;
9397            current = TREE_CHAIN (current))
9398         {
9399           output_class = current_class = TREE_TYPE (TREE_VALUE (current));
9400           if (flag_emit_class_files)
9401             write_classfile (current_class);
9402           else if (! flag_syntax_only)
9403             java_expand_method_bodies (current_class);
9404         }
9405     }
9406 }
9407
9408 void
9409 java_finish_classes (void)
9410 {
9411   static struct parser_ctxt *cur_ctxp = NULL;
9412   for (cur_ctxp = ctxp_for_generation; cur_ctxp; cur_ctxp = cur_ctxp->next)
9413     {
9414       tree current;
9415       ctxp = cur_ctxp;
9416       for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
9417         {
9418           output_class = current_class = TREE_TYPE (current);
9419           finish_class ();
9420         }
9421     }
9422 }
9423
9424 /* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
9425    a tree list node containing RIGHT. Fore coming RIGHTs will be
9426    chained to this hook. LOCATION contains the location of the
9427    separating `.' operator.  */
9428
9429 static tree
9430 make_qualified_primary (tree primary, tree right, int location)
9431 {
9432   tree wfl;
9433
9434   if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
9435     wfl = build_wfl_wrap (primary, location);
9436   else
9437     {
9438       wfl = primary;
9439       /* If wfl wasn't qualified, we build a first anchor */
9440       if (!EXPR_WFL_QUALIFICATION (wfl))
9441         EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (wfl, NULL_TREE);
9442     }
9443
9444   /* And chain them */
9445   EXPR_WFL_LINECOL (right) = location;
9446   chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
9447   PRIMARY_P (wfl) =  1;
9448   return wfl;
9449 }
9450
9451 /* Simple merge of two name separated by a `.' */
9452
9453 static tree
9454 merge_qualified_name (tree left, tree right)
9455 {
9456   tree node;
9457   if (!left && !right)
9458     return NULL_TREE;
9459
9460   if (!left)
9461     return right;
9462
9463   if (!right)
9464     return left;
9465
9466   obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
9467                 IDENTIFIER_LENGTH (left));
9468   obstack_1grow (&temporary_obstack, '.');
9469   obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
9470                  IDENTIFIER_LENGTH (right));
9471   node =  get_identifier (obstack_base (&temporary_obstack));
9472   obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
9473   QUALIFIED_P (node) = 1;
9474   return node;
9475 }
9476
9477 /* Merge the two parts of a qualified name into LEFT.  Set the
9478    location information of the resulting node to LOCATION, usually
9479    inherited from the location information of the `.' operator. */
9480
9481 static tree
9482 make_qualified_name (tree left, tree right,
9483 #ifdef USE_MAPPED_LOCATION
9484                      source_location location
9485 #else
9486                      int location
9487 #endif
9488                      )
9489 {
9490 #ifdef USE_COMPONENT_REF
9491   tree node = build3 (COMPONENT_REF, NULL_TREE, left, right, NULL_TREE);
9492   SET_EXPR_LOCATION (node, location);
9493   return node;
9494 #else
9495   tree left_id = EXPR_WFL_NODE (left);
9496   tree right_id = EXPR_WFL_NODE (right);
9497   tree wfl, merge;
9498
9499   merge = merge_qualified_name (left_id, right_id);
9500
9501   /* Left wasn't qualified and is now qualified */
9502 #ifdef USE_MAPPED_LOCATION
9503   if (!QUALIFIED_P (left_id))
9504     {
9505       tree wfl = build_expr_wfl (left_id, EXPR_LOCATION (left));
9506       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9507     }
9508
9509   wfl = build_expr_wfl (right_id, location);
9510 #else
9511   if (!QUALIFIED_P (left_id))
9512     {
9513       tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
9514       EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
9515       EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
9516     }
9517
9518   wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
9519   EXPR_WFL_LINECOL (wfl) = location;
9520 #endif
9521   chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
9522   EXPR_WFL_NODE (left) = merge;
9523   return left;
9524 #endif
9525 }
9526
9527 /* Extract the last identifier component of the qualified in WFL. The
9528    last identifier is removed from the linked list */
9529
9530 static tree
9531 cut_identifier_in_qualified (tree wfl)
9532 {
9533   tree q;
9534   tree previous = NULL_TREE;
9535   for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
9536     if (!TREE_CHAIN (q))
9537       {
9538         if (!previous)
9539           /* Operating on a non qualified qualified WFL.  */
9540           abort ();
9541
9542         TREE_CHAIN (previous) = NULL_TREE;
9543         return TREE_PURPOSE (q);
9544       }
9545 }
9546
9547 /* Resolve the expression name NAME. Return its decl.  */
9548
9549 static tree
9550 resolve_expression_name (tree id, tree *orig)
9551 {
9552   tree name = EXPR_WFL_NODE (id);
9553   tree decl;
9554
9555   /* 6.5.5.1: Simple expression names */
9556   if (!PRIMARY_P (id) && !QUALIFIED_P (name))
9557     {
9558       /* 15.13.1: NAME can appear within the scope of a local variable
9559          declaration */
9560       if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
9561         return decl;
9562
9563       /* 15.13.1: NAME can appear within a class declaration */
9564       else
9565         {
9566           decl = lookup_field_wrapper (current_class, name);
9567           if (decl)
9568             {
9569               tree access = NULL_TREE;
9570               int fs = FIELD_STATIC (decl);
9571
9572               /* If we're accessing an outer scope local alias, make
9573                  sure we change the name of the field we're going to
9574                  build access to. */
9575               if (FIELD_LOCAL_ALIAS_USED (decl))
9576                 name = DECL_NAME (decl);
9577
9578               check_deprecation (id, decl);
9579
9580               /* Instance variable (8.3.1.1) can't appear within
9581                  static method, static initializer or initializer for
9582                  a static variable. */
9583               if (!fs && METHOD_STATIC (current_function_decl))
9584                 {
9585                   static_ref_err (id, name, current_class);
9586                   return error_mark_node;
9587                 }
9588               /* Instance variables can't appear as an argument of
9589                  an explicit constructor invocation */
9590               if (!fs && ctxp->explicit_constructor_p
9591                   && !enclosing_context_p (DECL_CONTEXT (decl), current_class))
9592                 {
9593                   parse_error_context
9594                     (id, "Can't reference %qs before the superclass constructor has been called", IDENTIFIER_POINTER (name));
9595                   return error_mark_node;
9596                 }
9597
9598               /* If we're processing an inner class and we're trying
9599                  to access a field belonging to an outer class, build
9600                  the access to the field.
9601                  As usual, we have to treat initialized static final
9602                  variables as a special case.  */
9603               if (nested_member_access_p (current_class, decl)
9604                   && ! (JDECL_P (decl) && CLASS_FINAL_VARIABLE_P (decl)
9605                         && DECL_INITIAL (decl) != NULL_TREE
9606                         && (JSTRING_TYPE_P (TREE_TYPE (decl))
9607                             || JNUMERIC_TYPE_P (TREE_TYPE (decl)))
9608                         && TREE_CONSTANT (DECL_INITIAL (decl))))
9609                 {
9610                   if (!fs && CLASS_STATIC (TYPE_NAME (current_class)))
9611                     {
9612                       static_ref_err (id, DECL_NAME (decl), current_class);
9613                       return error_mark_node;
9614                     }
9615                   access = build_nested_field_access (id, decl);
9616                   if (orig)
9617                     *orig = access;
9618                   return access;
9619                 }
9620
9621               /* Otherwise build what it takes to access the field */
9622               access = build_field_ref ((fs ? NULL_TREE : current_this),
9623                                         DECL_CONTEXT (decl), name);
9624               if (fs)
9625                 access = maybe_build_class_init_for_field (decl, access);
9626               /* We may be asked to save the real field access node */
9627               if (orig)
9628                 *orig = access;
9629               /* Last check: can we access the field? */
9630               if (not_accessible_p (current_class, decl, NULL_TREE, 0))
9631                 {
9632                   not_accessible_field_error (id, decl);
9633                   return error_mark_node;
9634                 }
9635               /* And we return what we got */
9636               return access;
9637             }
9638           /* Fall down to error report on undefined variable */
9639         }
9640     }
9641   /* 6.5.5.2 Qualified Expression Names */
9642   else
9643     {
9644       if (orig)
9645         *orig = NULL_TREE;
9646       qualify_ambiguous_name (id);
9647       /* 15.10.1 Field Access Using a Primary and/or Expression Name */
9648       /* 15.10.2: Accessing Superclass Members using super */
9649       return resolve_field_access (id, orig, NULL);
9650     }
9651
9652   /* We've got an error here */
9653   if (INNER_CLASS_TYPE_P (current_class))
9654     parse_error_context (id,
9655                          "Local variable %qs can't be accessed from within the inner class %qs unless it is declared final",
9656                          IDENTIFIER_POINTER (name),
9657                          IDENTIFIER_POINTER (DECL_NAME
9658                                              (TYPE_NAME (current_class))));
9659   else
9660     parse_error_context (id, "Undefined variable %qs",
9661                          IDENTIFIER_POINTER (name));
9662
9663   return error_mark_node;
9664 }
9665
9666 static void
9667 static_ref_err (tree wfl, tree field_id, tree class_type)
9668 {
9669   parse_error_context
9670     (wfl,
9671      "Can't make a static reference to nonstatic variable %qs in class %qs",
9672      IDENTIFIER_POINTER (field_id),
9673      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))));
9674 }
9675
9676 /* 15.10.1 Field Access Using a Primary and/or Expression Name.
9677    We return something suitable to generate the field access. We also
9678    return the field decl in FIELD_DECL and its type in FIELD_TYPE.  If
9679    recipient's address can be null. */
9680
9681 static tree
9682 resolve_field_access (tree qual_wfl, tree *field_decl, tree *field_type)
9683 {
9684   int is_static = 0;
9685   tree field_ref;
9686   tree decl = NULL_TREE, where_found, type_found;
9687
9688   if (resolve_qualified_expression_name (qual_wfl, &decl,
9689                                          &where_found, &type_found))
9690     return error_mark_node;
9691
9692   /* Resolve the LENGTH field of an array here */
9693   if (DECL_P (decl) && DECL_NAME (decl) == length_identifier_node
9694       && type_found && TYPE_ARRAY_P (type_found)
9695       && ! flag_emit_class_files)
9696     {
9697       tree length = build_java_array_length_access (where_found);
9698       field_ref = length;
9699
9700       /* In case we're dealing with a static array, we need to
9701          initialize its class before the array length can be fetched.  */
9702       if (TREE_CODE (where_found) == VAR_DECL && FIELD_STATIC (where_found))
9703         {
9704           build_static_field_ref (where_found);
9705           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9706         }
9707     }
9708   /* We might have been trying to resolve field.method(). In which
9709      case, the resolution is over and decl is the answer */
9710   else if (JDECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
9711     field_ref = decl;
9712   else if (JDECL_P (decl))
9713     {
9714       if (!type_found)
9715         type_found = DECL_CONTEXT (decl);
9716       is_static = FIELD_STATIC (decl);
9717       field_ref = build_field_ref ((is_static ?
9718                                     NULL_TREE : where_found),
9719                                    type_found, DECL_NAME (decl));
9720       if (field_ref == error_mark_node)
9721         return error_mark_node;
9722       if (is_static)
9723         field_ref = maybe_build_class_init_for_field (decl, field_ref);
9724
9725       /* If we're looking at a static field, we may need to generate a
9726          class initialization for it.  This can happen when the access
9727          looks like `field.ref', where `field' is a static field in an
9728          interface we implement.  */
9729       if (!flag_emit_class_files
9730           && TREE_CODE (where_found) == VAR_DECL
9731           && FIELD_STATIC (where_found))
9732         {
9733           build_static_field_ref (where_found);
9734           field_ref = build_class_init (DECL_CONTEXT (where_found), field_ref);
9735         }
9736     }
9737   else
9738     field_ref = decl;
9739
9740   if (field_decl)
9741     *field_decl = decl;
9742   if (field_type)
9743     *field_type = (QUAL_DECL_TYPE (decl) ?
9744                    QUAL_DECL_TYPE (decl) : TREE_TYPE (decl));
9745   return field_ref;
9746 }
9747
9748 /* If NODE is an access to a static field, strip out the class
9749    initialization part and return the field decl, otherwise, return
9750    NODE. */
9751
9752 tree
9753 extract_field_decl (tree node)
9754 {
9755   if (TREE_CODE (node) == COMPOUND_EXPR)
9756     {
9757       tree op1 = TREE_OPERAND (node, 1);
9758       if (TREE_CODE (op1) == COMPOUND_EXPR)
9759          {
9760            tree call = TREE_OPERAND (op1, 0);
9761            if (TREE_CODE (call) == CALL_EXPR
9762                && TREE_CODE (TREE_OPERAND (call, 0)) == ADDR_EXPR
9763                && (TREE_OPERAND (TREE_OPERAND (call, 0), 0)
9764                    == soft_initclass_node))
9765              return TREE_OPERAND (op1, 1);
9766          }
9767       else if (JDECL_P (op1))
9768         return op1;
9769     }
9770   return node;
9771 }
9772
9773 /* 6.5.5.2: Qualified Expression Names */
9774
9775 static int
9776 resolve_qualified_expression_name (tree wfl, tree *found_decl,
9777                                    tree *where_found, tree *type_found)
9778 {
9779   int from_type = 0;            /* Field search initiated from a type */
9780   int from_super = 0, from_cast = 0, from_qualified_this = 0;
9781   int previous_call_static = 0;
9782   int is_static;
9783   tree decl = NULL_TREE, type = NULL_TREE, q;
9784   /* For certain for of inner class instantiation */
9785   tree saved_current, saved_this;
9786 #define RESTORE_THIS_AND_CURRENT_CLASS                          \
9787   { current_class = saved_current; current_this = saved_this;}
9788
9789   *type_found = *where_found = NULL_TREE;
9790
9791   for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
9792     {
9793       tree qual_wfl = QUAL_WFL (q);
9794       tree ret_decl;            /* for EH checking */
9795 #ifdef USE_MAPPED_LOCATION
9796       source_location location;  /* for EH checking */
9797 #else
9798       int location;             /* for EH checking */
9799 #endif
9800
9801       /* 15.10.1 Field Access Using a Primary */
9802       switch (TREE_CODE (qual_wfl))
9803         {
9804         case CALL_EXPR:
9805         case NEW_CLASS_EXPR:
9806           /* If the access to the function call is a non static field,
9807              build the code to access it. */
9808           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9809             {
9810               decl = maybe_access_field (decl, *where_found,
9811                                          DECL_CONTEXT (decl));
9812               if (decl == error_mark_node)
9813                 return 1;
9814             }
9815
9816           /* And code for the function call */
9817           if (complete_function_arguments (qual_wfl))
9818             return 1;
9819
9820           /* We might have to setup a new current class and a new this
9821              for the search of an inner class, relative to the type of
9822              a expression resolved as `decl'. The current values are
9823              saved and restored shortly after */
9824           saved_current = current_class;
9825           saved_this = current_this;
9826           if (decl
9827               && (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9828                   || from_qualified_this))
9829             {
9830               /* If we still have `from_qualified_this', we have the form
9831                  <T>.this.f() and we need to build <T>.this */
9832               if (from_qualified_this)
9833                 {
9834                   decl = build_access_to_thisn (current_class, type, 0);
9835                   decl = java_complete_tree (decl);
9836                   type = TREE_TYPE (TREE_TYPE (decl));
9837                 }
9838               current_class = type;
9839               current_this = decl;
9840               from_qualified_this = 0;
9841             }
9842
9843           if (from_super && TREE_CODE (qual_wfl) == CALL_EXPR)
9844             CALL_USING_SUPER (qual_wfl) = 1;
9845 #ifdef USE_MAPPED_LOCATION
9846           location = (TREE_CODE (qual_wfl) == CALL_EXPR
9847                       ? EXPR_LOCATION (TREE_OPERAND (qual_wfl, 0))
9848                       : UNKNOWN_LOCATION);
9849 #else
9850           location = (TREE_CODE (qual_wfl) == CALL_EXPR ?
9851                       EXPR_WFL_LINECOL (TREE_OPERAND (qual_wfl, 0)) : 0);
9852 #endif
9853           *where_found = patch_method_invocation (qual_wfl, decl, type,
9854                                                   from_super,
9855                                                   &is_static, &ret_decl);
9856           from_super = 0;
9857           if (*where_found == error_mark_node)
9858             {
9859               RESTORE_THIS_AND_CURRENT_CLASS;
9860               return 1;
9861             }
9862           *type_found = type = QUAL_DECL_TYPE (*where_found);
9863
9864           *where_found = force_evaluation_order (*where_found);
9865
9866           /* If we're creating an inner class instance, check for that
9867              an enclosing instance is in scope */
9868           if (TREE_CODE (qual_wfl) == NEW_CLASS_EXPR
9869               && INNER_ENCLOSING_SCOPE_CHECK (type))
9870             {
9871               parse_error_context
9872                 (qual_wfl, "No enclosing instance for inner class %qs is in scope%s",
9873                  lang_printable_name (type, 0),
9874                  (!current_this ? "" :
9875                   "; an explicit one must be provided when creating this inner class"));
9876               RESTORE_THIS_AND_CURRENT_CLASS;
9877               return 1;
9878             }
9879
9880           /* In case we had to change then to resolve a inner class
9881              instantiation using a primary qualified by a `new' */
9882           RESTORE_THIS_AND_CURRENT_CLASS;
9883
9884 #ifdef USE_MAPPED_LOCATION
9885           if (location != UNKNOWN_LOCATION)
9886 #else
9887           if (location)
9888 #endif
9889             {
9890               tree arguments = NULL_TREE;
9891               if (TREE_CODE (qual_wfl) == CALL_EXPR
9892                   && TREE_OPERAND (qual_wfl, 1) != NULL_TREE)
9893                 arguments = TREE_VALUE (TREE_OPERAND (qual_wfl, 1));
9894               check_thrown_exceptions (location, ret_decl, arguments);
9895             }
9896
9897           /* If the previous call was static and this one is too,
9898              build a compound expression to hold the two (because in
9899              that case, previous function calls aren't transported as
9900              forcoming function's argument. */
9901           if (previous_call_static && is_static)
9902             {
9903               /* We must set CAN_COMPLETE_NORMALLY for the first call
9904                  since it is done nowhere else.  */
9905               CAN_COMPLETE_NORMALLY (decl) = 1;
9906               decl = build2 (COMPOUND_EXPR, TREE_TYPE (*where_found),
9907                              decl, *where_found);
9908               TREE_SIDE_EFFECTS (decl) = 1;
9909             }
9910           else
9911             {
9912               previous_call_static = is_static;
9913               decl = *where_found;
9914             }
9915           from_type = 0;
9916           continue;
9917
9918         case NEW_ARRAY_EXPR:
9919         case NEW_ANONYMOUS_ARRAY_EXPR:
9920           *where_found = decl = java_complete_tree (qual_wfl);
9921           if (decl == error_mark_node)
9922             return 1;
9923           *type_found = type = QUAL_DECL_TYPE (decl);
9924           continue;
9925
9926         case CONVERT_EXPR:
9927           *where_found = decl = java_complete_tree (qual_wfl);
9928           if (decl == error_mark_node)
9929             return 1;
9930           *type_found = type = QUAL_DECL_TYPE (decl);
9931           from_cast = 1;
9932           continue;
9933
9934         case CONDITIONAL_EXPR:
9935         case STRING_CST:
9936         case MODIFY_EXPR:
9937           *where_found = decl = java_complete_tree (qual_wfl);
9938           if (decl == error_mark_node)
9939             return 1;
9940           *type_found = type = QUAL_DECL_TYPE (decl);
9941           continue;
9942
9943         case ARRAY_REF:
9944           /* If the access to the function call is a non static field,
9945              build the code to access it. */
9946           if (JDECL_P (decl) && !FIELD_STATIC (decl))
9947             {
9948               decl = maybe_access_field (decl, *where_found, type);
9949               if (decl == error_mark_node)
9950                 return 1;
9951             }
9952           /* And code for the array reference expression */
9953           decl = java_complete_tree (qual_wfl);
9954           if (decl == error_mark_node)
9955             return 1;
9956           type = QUAL_DECL_TYPE (decl);
9957           continue;
9958
9959         case PLUS_EXPR:
9960           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9961             return 1;
9962           if ((type = patch_string (decl)))
9963             decl = type;
9964           *where_found = QUAL_RESOLUTION (q) = decl;
9965           *type_found = type = TREE_TYPE (decl);
9966           break;
9967
9968         case CLASS_LITERAL:
9969           if ((decl = java_complete_tree (qual_wfl)) == error_mark_node)
9970             return 1;
9971           *where_found = QUAL_RESOLUTION (q) = decl;
9972           *type_found = type = TREE_TYPE (decl);
9973           break;
9974
9975         default:
9976           /* Fix for -Wall Just go to the next statement. Don't
9977              continue */
9978           break;
9979         }
9980
9981       /* If we fall here, we weren't processing a (static) function call. */
9982       previous_call_static = 0;
9983
9984       /* It can be the keyword THIS */
9985       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
9986           && EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
9987         {
9988           if (!current_this)
9989             {
9990               parse_error_context
9991                 (wfl, "Keyword %<this%> used outside allowed context");
9992               return 1;
9993             }
9994           if (ctxp->explicit_constructor_p
9995               && type == current_class)
9996             {
9997               parse_error_context (wfl, "Can't reference %<this%> before the superclass constructor has been called");
9998               return 1;
9999             }
10000           /* We have to generate code for intermediate access */
10001           if (!from_type || TREE_TYPE (TREE_TYPE (current_this)) == type)
10002             {
10003               *where_found = decl = current_this;
10004               *type_found = type = QUAL_DECL_TYPE (decl);
10005             }
10006           /* We're trying to access the this from somewhere else. Make sure
10007              it's allowed before doing so. */
10008           else
10009             {
10010               if (!enclosing_context_p (type, current_class))
10011                 {
10012                   char *p  = xstrdup (lang_printable_name (type, 0));
10013                   parse_error_context (qual_wfl, "Can't use variable %<%s.this%>: type %qs isn't an outer type of type %qs",
10014                                        p, p,
10015                                        lang_printable_name (current_class, 0));
10016                   free (p);
10017                   return 1;
10018                 }
10019               from_qualified_this = 1;
10020               /* If there's nothing else after that, we need to
10021                  produce something now, otherwise, the section of the
10022                  code that needs to produce <T>.this will generate
10023                  what is necessary. */
10024               if (!TREE_CHAIN (q))
10025                 {
10026                   decl = build_access_to_thisn (current_class, type, 0);
10027                   *where_found = decl = java_complete_tree (decl);
10028                   *type_found = type = TREE_TYPE (decl);
10029                 }
10030             }
10031
10032           from_type = 0;
10033           continue;
10034         }
10035
10036       /* 15.10.2 Accessing Superclass Members using SUPER */
10037       if (TREE_CODE (qual_wfl) == EXPR_WITH_FILE_LOCATION
10038           && EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
10039         {
10040           tree node;
10041           /* Check on the restricted use of SUPER */
10042           if (METHOD_STATIC (current_function_decl)
10043               || current_class == object_type_node)
10044             {
10045               parse_error_context
10046                 (wfl, "Keyword %<super%> used outside allowed context");
10047               return 1;
10048             }
10049           /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
10050           node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
10051                              CLASSTYPE_SUPER (current_class),
10052                              build_this (EXPR_WFL_LINECOL (qual_wfl)));
10053           *where_found = decl = java_complete_tree (node);
10054           if (decl == error_mark_node)
10055             return 1;
10056           *type_found = type = QUAL_DECL_TYPE (decl);
10057           from_super = from_type = 1;
10058           continue;
10059         }
10060
10061       /* 15.13.1: Can't search for field name in packages, so we
10062          assume a variable/class name was meant. */
10063       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
10064         {
10065           tree name;
10066           if ((decl = resolve_package (wfl, &q, &name)))
10067             {
10068               tree list;
10069               *where_found = decl;
10070
10071               check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
10072
10073               /* We want to be absolutely sure that the class is laid
10074                  out. We're going to search something inside it. */
10075               *type_found = type = TREE_TYPE (decl);
10076               layout_class (type);
10077               from_type = 1;
10078
10079               /* Fix them all the way down, if any are left. */
10080               if (q)
10081                 {
10082                   list = TREE_CHAIN (q);
10083                   while (list)
10084                     {
10085                       RESOLVE_PACKAGE_NAME_P (QUAL_WFL (list)) = 0;
10086                       list = TREE_CHAIN (list);
10087                     }
10088                 }
10089             }
10090           else
10091             {
10092               if (from_super || from_cast)
10093                 parse_error_context
10094                   ((from_cast ? qual_wfl : wfl),
10095                    "No variable %qs defined in class %qs",
10096                    IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
10097                    lang_printable_name (type, 0));
10098               else
10099                 parse_error_context
10100                   (qual_wfl, "Undefined variable or class name: %qs",
10101                    IDENTIFIER_POINTER (name));
10102               return 1;
10103             }
10104         }
10105
10106       /* We have a type name. It's been already resolved when the
10107          expression was qualified. */
10108       else if (RESOLVE_TYPE_NAME_P (qual_wfl) && QUAL_RESOLUTION (q))
10109         {
10110           decl = QUAL_RESOLUTION (q);
10111
10112           /* Sneak preview. If next we see a `new', we're facing a
10113              qualification which resulted in a type being selected
10114              instead of a field.  Report the error.  */
10115           if(TREE_CHAIN (q)
10116              && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR)
10117             {
10118               parse_error_context (qual_wfl, "Undefined variable %qs",
10119                                    IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10120               return 1;
10121             }
10122
10123           check_pkg_class_access (DECL_NAME (decl), qual_wfl, true, NULL);
10124
10125           check_deprecation (qual_wfl, decl);
10126
10127           type = TREE_TYPE (decl);
10128           from_type = 1;
10129         }
10130       /* We resolve an expression name */
10131       else
10132         {
10133           tree field_decl = NULL_TREE;
10134
10135           /* If there exists an early resolution, use it. That occurs
10136              only once and we know that there are more things to
10137              come. Don't do that when processing something after SUPER
10138              (we need more thing to be put in place below */
10139           if (!from_super && QUAL_RESOLUTION (q))
10140             {
10141               decl = QUAL_RESOLUTION (q);
10142               if (!type)
10143                 {
10144                   if (TREE_CODE (decl) == FIELD_DECL
10145                       || TREE_CODE (decl) == VAR_DECL)
10146                     {
10147                       if (TREE_CODE (decl) == FIELD_DECL
10148                           && !FIELD_STATIC (decl))
10149                         {
10150                           if (current_this)
10151                             *where_found = current_this;
10152                           else
10153                             {
10154                               static_ref_err (qual_wfl, DECL_NAME (decl),
10155                                               current_class);
10156                               return 1;
10157                             }
10158                         }
10159                       else
10160                         {
10161                           *where_found = TREE_TYPE (decl);
10162                           if (TREE_CODE (*where_found) == POINTER_TYPE)
10163                             *where_found = TREE_TYPE (*where_found);
10164                         }
10165                       if (nested_member_access_p (current_class, decl))
10166                         decl = build_nested_field_access (qual_wfl, decl);
10167                     }
10168                   else
10169                     {
10170                       *where_found = TREE_TYPE (decl);
10171                       if (TREE_CODE (*where_found) == POINTER_TYPE)
10172                         *where_found = TREE_TYPE (*where_found);
10173                     }
10174                 }
10175             }
10176
10177           /* Report and error if we're using a numerical literal as a
10178              qualifier. It can only be an INTEGER_CST. */
10179           else if (TREE_CODE (qual_wfl) == INTEGER_CST)
10180             {
10181               parse_error_context
10182                 (wfl, "Can't use type %qs as a qualifier",
10183                  lang_printable_name (TREE_TYPE (qual_wfl), 0));
10184               return 1;
10185             }
10186
10187           /* We have to search for a field, knowing the type of its
10188              container. The flag FROM_TYPE indicates that we resolved
10189              the last member of the expression as a type name, which
10190              means that for the resolution of this field, we'll look
10191              for other errors than if it was resolved as a member of
10192              an other field. */
10193           else
10194             {
10195               int is_static;
10196               tree field_decl_type; /* For layout */
10197
10198               if (!from_type && !JREFERENCE_TYPE_P (type))
10199                 {
10200                   parse_error_context
10201                     (qual_wfl, "Attempt to reference field %qs in %<%s %s%>",
10202                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
10203                      lang_printable_name (type, 0),
10204                      IDENTIFIER_POINTER (DECL_NAME (decl)));
10205                   return 1;
10206                 }
10207
10208               field_decl = lookup_field_wrapper (type,
10209                                                  EXPR_WFL_NODE (qual_wfl));
10210
10211               /* Maybe what we're trying to access to is an inner
10212                  class, only if decl is a TYPE_DECL. */
10213               if (!field_decl && TREE_CODE (decl) == TYPE_DECL)
10214                 {
10215                   tree ptr, inner_decl;
10216
10217                   BUILD_PTR_FROM_NAME (ptr, EXPR_WFL_NODE (qual_wfl));
10218                   inner_decl = resolve_class (decl, ptr, NULL_TREE, qual_wfl);
10219                   if (inner_decl)
10220                     {
10221                       check_inner_class_access (inner_decl, decl, qual_wfl);
10222                       type = TREE_TYPE (inner_decl);
10223                       decl = inner_decl;
10224                       from_type = 1;
10225                       continue;
10226                     }
10227                 }
10228
10229               if (field_decl == NULL_TREE)
10230                 {
10231                   parse_error_context
10232                     (qual_wfl, "No variable %qs defined in type %qs",
10233                      IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
10234                      GET_TYPE_NAME (type));
10235                   return 1;
10236                 }
10237               if (field_decl == error_mark_node)
10238                 return 1;
10239
10240               /* Layout the type of field_decl, since we may need
10241                  it. Don't do primitive types or loaded classes. The
10242                  situation of non primitive arrays may not handled
10243                  properly here. FIXME */
10244               if (TREE_CODE (TREE_TYPE (field_decl)) == POINTER_TYPE)
10245                 field_decl_type = TREE_TYPE (TREE_TYPE (field_decl));
10246               else
10247                 field_decl_type = TREE_TYPE (field_decl);
10248               if (!JPRIMITIVE_TYPE_P (field_decl_type)
10249                   && !CLASS_LOADED_P (field_decl_type)
10250                   && !TYPE_ARRAY_P (field_decl_type))
10251                 resolve_and_layout (field_decl_type, NULL_TREE);
10252
10253               /* Check on accessibility here */
10254               if (not_accessible_p (current_class, field_decl,
10255                                     *type_found, from_super))
10256                 return not_accessible_field_error (qual_wfl,field_decl);
10257               check_deprecation (qual_wfl, field_decl);
10258
10259               /* There are things to check when fields are accessed
10260                  from type. There are no restrictions on a static
10261                  declaration of the field when it is accessed from an
10262                  interface */
10263               is_static = FIELD_STATIC (field_decl);
10264               if (!from_super && from_type
10265                   && !TYPE_INTERFACE_P (type)
10266                   && !is_static
10267                   && (current_function_decl
10268                       && METHOD_STATIC (current_function_decl)))
10269                 {
10270                   static_ref_err (qual_wfl, EXPR_WFL_NODE (qual_wfl), type);
10271                   return 1;
10272                 }
10273               from_cast = from_super = 0;
10274
10275               /* If it's an access from a type but isn't static, we
10276                  make it relative to `this'. */
10277               if (!is_static && from_type)
10278                 decl = current_this;
10279
10280               /* If we need to generate something to get a proper
10281                  handle on what this field is accessed from, do it
10282                  now. */
10283               if (!is_static)
10284                 {
10285                   decl = maybe_access_field (decl, *where_found, *type_found);
10286                   if (decl == error_mark_node)
10287                     return 1;
10288                 }
10289
10290               /* We want to keep the location where we found it, and the
10291                  type we found.  */
10292               *where_found = decl;
10293               *type_found = type;
10294
10295               /* Generate the correct expression for field access from
10296                  qualified this */
10297               if (from_qualified_this)
10298                 {
10299                   field_decl
10300                     = build_nested_field_access (qual_wfl, field_decl);
10301                   from_qualified_this = 0;
10302                 }
10303
10304               /* If needed, generate accessors for static field access.  */
10305               if (is_static
10306                   && FIELD_PRIVATE (field_decl)
10307                   && flag_emit_class_files
10308                   && nested_member_access_p (current_class, field_decl))
10309                 field_decl = build_nested_field_access (qual_wfl, field_decl);
10310
10311               /* This is the decl found and eventually the next one to
10312                  search from */
10313               decl = field_decl;
10314             }
10315           from_type = 0;
10316           type = QUAL_DECL_TYPE (decl);
10317
10318           /* Sneak preview. If decl is qualified by a `new', report
10319              the error here to be accurate on the peculiar construct */
10320           if (TREE_CHAIN (q)
10321               && TREE_CODE (TREE_PURPOSE (TREE_CHAIN (q))) == NEW_CLASS_EXPR
10322               && !JREFERENCE_TYPE_P (type))
10323             {
10324               parse_error_context (qual_wfl, "Attempt to reference field %<new%> in a %qs",
10325                                    lang_printable_name (type, 0));
10326               return 1;
10327             }
10328         }
10329       /* `q' might have changed due to a after package resolution
10330          re-qualification */
10331       if (!q)
10332         break;
10333     }
10334   *found_decl = decl;
10335   return 0;
10336 }
10337
10338 /* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
10339    can't be accessed from REFERENCE (a record type). If MEMBER
10340    features a protected access, we then use WHERE which, if non null,
10341    holds the type of MEMBER's access that is checked against
10342    6.6.2.1. This function should be used when decl is a field or a
10343    method.  */
10344
10345 static int
10346 not_accessible_p (tree reference, tree member, tree where, int from_super)
10347 {
10348   int access_flag = get_access_flags_from_decl (member);
10349   bool is_static = false;
10350
10351   if (TREE_CODE (member) == FIELD_DECL ||
10352       TREE_CODE (member) == VAR_DECL)
10353     is_static = FIELD_STATIC (member);
10354   else
10355     is_static = METHOD_STATIC (member);
10356
10357   /* Access always granted for members declared public */
10358   if (access_flag & ACC_PUBLIC)
10359     return 0;
10360
10361   /* Check access on protected members */
10362   if (access_flag & ACC_PROTECTED)
10363     {
10364       /* Access granted if it occurs from within the package
10365          containing the class in which the protected member is
10366          declared */
10367       if (class_in_current_package (DECL_CONTEXT (member)))
10368         return 0;
10369
10370       /* If accessed with the form `super.member', then access is granted */
10371       if (from_super)
10372         return 0;
10373
10374       /* If WHERE is active, access was made through a qualifier. For
10375          non-static members, access is granted if the type of the qualifier
10376          is or is a sublass of the type the access is made from (6.6.2.1.)  */
10377       if (where && !is_static)
10378         {
10379           while (reference)
10380             {
10381               if (inherits_from_p (where, reference))
10382                 return 0;
10383               if (INNER_CLASS_TYPE_P (reference))
10384                 reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10385               else
10386                 break;
10387             }
10388           return 1;
10389         }
10390
10391       /* Otherwise, access is granted if occurring from within the class
10392          where member is declared, or a subclass of it.  */
10393       while (reference)
10394         {
10395           if (inherits_from_p (reference, DECL_CONTEXT (member)))
10396             return 0;
10397           if (INNER_CLASS_TYPE_P (reference))
10398             reference = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (reference)));
10399           else
10400             break;
10401         }
10402       return 1;
10403     }
10404
10405   /* Check access on private members. Access is granted only if it
10406      occurs from within the class in which it is declared -- that does
10407      it for innerclasses too. */
10408   if (access_flag & ACC_PRIVATE)
10409     {
10410       if (reference == DECL_CONTEXT (member) ||
10411           common_enclosing_context_p (DECL_CONTEXT (member), reference))
10412         return 0;
10413       return 1;
10414     }
10415
10416   /* Default access is permitted only when occurring from within the
10417      package in which the context (MEMBER) is declared.  */
10418   return !class_in_current_package (DECL_CONTEXT (member));
10419 }
10420
10421 /* Test deprecated decl access.  */
10422 static void
10423 check_deprecation (tree wfl, tree decl)
10424 {
10425   const char *file;
10426   tree elt;
10427
10428   if (! warn_deprecated)
10429     return;
10430
10431   /* We want to look at the element type of arrays here, so we strip
10432      all surrounding array types.  */
10433   if (TYPE_ARRAY_P (TREE_TYPE (decl)))
10434     {
10435       elt = TREE_TYPE (decl);
10436       while (TYPE_ARRAY_P (elt))
10437         elt = TYPE_ARRAY_ELEMENT (elt);
10438       /* We'll end up with a pointer type, so we use TREE_TYPE to go
10439          to the record.  */
10440       decl = TYPE_NAME (TREE_TYPE (elt));
10441     }
10442   file = DECL_SOURCE_FILE (decl);
10443
10444   /* Complain if the field is deprecated and the file it was defined
10445      in isn't compiled at the same time the file which contains its
10446      use is */
10447   if (DECL_DEPRECATED (decl)
10448       && !IS_A_COMMAND_LINE_FILENAME_P (get_identifier (file)))
10449     {
10450       const char *the;
10451       switch (TREE_CODE (decl))
10452         {
10453         case FUNCTION_DECL:
10454           the = "method";
10455           break;
10456         case FIELD_DECL:
10457         case VAR_DECL:
10458           the = "field";
10459           break;
10460         case TYPE_DECL:
10461           parse_warning_context (wfl, "The class %qs has been deprecated",
10462                                  IDENTIFIER_POINTER (DECL_NAME (decl)));
10463           return;
10464         default:
10465           abort ();
10466         }
10467       /* Don't issue a message if the context as been deprecated as a
10468          whole. */
10469       if (! CLASS_DEPRECATED (TYPE_NAME (DECL_CONTEXT (decl))))
10470         parse_warning_context
10471           (wfl, "The %s %qs in class %qs has been deprecated",
10472            the, lang_printable_name (decl, 0),
10473            IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))));
10474     }
10475 }
10476
10477 /* Returns 1 if class was declared in the current package, 0 otherwise */
10478
10479 static int
10480 class_in_current_package (tree class)
10481 {
10482   if (TYPE_PACKAGE (current_class) == TYPE_PACKAGE (class))
10483     return 1;
10484   return 0;
10485 }
10486
10487 /* This function may generate code to access DECL from WHERE. This is
10488    done only if certain conditions meet.  */
10489
10490 static tree
10491 maybe_access_field (tree decl, tree where, tree type)
10492 {
10493   if (TREE_CODE (decl) == FIELD_DECL && decl != current_this
10494       && !FIELD_STATIC (decl))
10495     decl = build_field_ref (where ? where : current_this,
10496                             (type ? type : DECL_CONTEXT (decl)),
10497                             DECL_NAME (decl));
10498   return decl;
10499 }
10500
10501 /* Build a method invocation, by patching PATCH. If non NULL
10502    and according to the situation, PRIMARY and WHERE may be
10503    used. IS_STATIC is set to 1 if the invoked function is static. */
10504
10505 static tree
10506 patch_method_invocation (tree patch, tree primary, tree where, int from_super,
10507                          int *is_static, tree *ret_decl)
10508 {
10509   tree wfl = TREE_OPERAND (patch, 0);
10510   tree args = TREE_OPERAND (patch, 1);
10511   tree name = EXPR_WFL_NODE (wfl);
10512   tree list;
10513   int is_static_flag = 0;
10514   int is_super_init = 0;
10515   tree this_arg = NULL_TREE;
10516   int is_array_clone_call = 0;
10517
10518   /* Should be overridden if everything goes well. Otherwise, if
10519      something fails, it should keep this value. It stop the
10520      evaluation of a bogus assignment. See java_complete_tree,
10521      MODIFY_EXPR: for the reasons why we sometimes want to keep on
10522      evaluating an assignment */
10523   TREE_TYPE (patch) = error_mark_node;
10524
10525   /* Since lookup functions are messing with line numbers, save the
10526      context now.  */
10527   java_parser_context_save_global ();
10528
10529   /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
10530
10531   /* Resolution of qualified name, excluding constructors */
10532   if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
10533     {
10534       tree identifier, identifier_wfl, type, resolved;
10535       /* Extract the last IDENTIFIER of the qualified
10536          expression. This is a wfl and we will use it's location
10537          data during error report. */
10538       identifier_wfl = cut_identifier_in_qualified (wfl);
10539       identifier = EXPR_WFL_NODE (identifier_wfl);
10540
10541       /* Given the context, IDENTIFIER is syntactically qualified
10542          as a MethodName. We need to qualify what's before */
10543       qualify_ambiguous_name (wfl);
10544       resolved = resolve_field_access (wfl, NULL, NULL);
10545
10546       if (TREE_CODE (resolved) == VAR_DECL && FIELD_STATIC (resolved)
10547          && FIELD_FINAL (resolved)
10548          && !inherits_from_p (DECL_CONTEXT (resolved), current_class)
10549          && !flag_emit_class_files)
10550        resolved = build_class_init (DECL_CONTEXT (resolved), resolved);
10551
10552       if (resolved == error_mark_node)
10553         PATCH_METHOD_RETURN_ERROR ();
10554
10555       type = GET_SKIP_TYPE (resolved);
10556       resolve_and_layout (type, NULL_TREE);
10557
10558       if (JPRIMITIVE_TYPE_P (type))
10559         {
10560           parse_error_context
10561             (identifier_wfl,
10562              "Can't invoke a method on primitive type %qs",
10563              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10564           PATCH_METHOD_RETURN_ERROR ();
10565         }
10566
10567       list = lookup_method_invoke (0, identifier_wfl, type, identifier, args);
10568       args = nreverse (args);
10569
10570       /* We're resolving a call from a type */
10571       if (TREE_CODE (resolved) == TYPE_DECL)
10572         {
10573           if (CLASS_INTERFACE (resolved))
10574             {
10575               parse_error_context
10576                 (identifier_wfl,
10577                 "Can't make static reference to method %qs in interface %qs",
10578                  IDENTIFIER_POINTER (identifier),
10579                  IDENTIFIER_POINTER (name));
10580               PATCH_METHOD_RETURN_ERROR ();
10581             }
10582           if (list)
10583             {
10584               if (METHOD_STATIC (list))
10585                 maybe_use_access_method (0, &list, NULL);
10586               else
10587                 {
10588                   char *fct_name = xstrdup (lang_printable_name (list, 2));
10589                   parse_error_context
10590                     (identifier_wfl,
10591                      "Can't make static reference to method %<%s %s%> in class %qs",
10592                      lang_printable_name (TREE_TYPE (TREE_TYPE (list)), 0),
10593                      fct_name,
10594                      IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
10595                   free (fct_name);
10596                   PATCH_METHOD_RETURN_ERROR ();
10597                 }
10598             }
10599         }
10600       else
10601         this_arg = primary = resolved;
10602
10603       if (TYPE_ARRAY_P (type) && identifier == get_identifier ("clone"))
10604         is_array_clone_call = 1;
10605
10606       /* IDENTIFIER_WFL will be used to report any problem further */
10607       wfl = identifier_wfl;
10608     }
10609   /* Resolution of simple names, names generated after a primary: or
10610      constructors */
10611   else
10612     {
10613       tree class_to_search = NULL_TREE;
10614       int lc;                   /* Looking for Constructor */
10615
10616       /* We search constructor in their target class */
10617       if (CALL_CONSTRUCTOR_P (patch))
10618         {
10619           if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10620             class_to_search = EXPR_WFL_NODE (wfl);
10621           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10622                    this_identifier_node)
10623             class_to_search = NULL_TREE;
10624           else if (EXPR_WFL_NODE (TREE_OPERAND (patch, 0)) ==
10625                    super_identifier_node)
10626             {
10627               is_super_init = 1;
10628               if (CLASSTYPE_SUPER (current_class))
10629                 class_to_search =
10630                   DECL_NAME (TYPE_NAME (CLASSTYPE_SUPER (current_class)));
10631               else
10632                 {
10633                   parse_error_context (wfl, "Can't invoke super constructor on java.lang.Object");
10634                   PATCH_METHOD_RETURN_ERROR ();
10635                 }
10636             }
10637
10638           /* Class to search is NULL if we're searching the current one */
10639           if (class_to_search)
10640             {
10641               class_to_search = resolve_and_layout (class_to_search, wfl);
10642
10643               if (!class_to_search)
10644                 {
10645                   parse_error_context
10646                     (wfl, "Class %qs not found in type declaration",
10647                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10648                   PATCH_METHOD_RETURN_ERROR ();
10649                 }
10650
10651               /* Can't instantiate an abstract class, but we can
10652                  invoke it's constructor. It's use within the `new'
10653                  context is denied here. */
10654               if (CLASS_ABSTRACT (class_to_search)
10655                   && TREE_CODE (patch) == NEW_CLASS_EXPR)
10656                 {
10657                   parse_error_context
10658                     (wfl, "Class %qs is an abstract class. It can't be instantiated",
10659                      IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
10660                   PATCH_METHOD_RETURN_ERROR ();
10661                 }
10662
10663               class_to_search = TREE_TYPE (class_to_search);
10664             }
10665           else
10666             class_to_search = current_class;
10667           lc = 1;
10668         }
10669       /* This is a regular search in the local class, unless an
10670          alternate class is specified. */
10671       else
10672         {
10673           if (where != NULL_TREE)
10674             class_to_search = where;
10675           else if (QUALIFIED_P (name))
10676             class_to_search = current_class;
10677           else
10678             {
10679               class_to_search = current_class;
10680
10681               for (;;)
10682                 {
10683                   if (has_method (class_to_search, name))
10684                     break;
10685                   if (! INNER_CLASS_TYPE_P (class_to_search))
10686                     {
10687                       parse_error_context (wfl,
10688                                            "No method named %qs in scope",
10689                                            IDENTIFIER_POINTER (name));
10690                       PATCH_METHOD_RETURN_ERROR ();
10691                     }
10692                   class_to_search
10693                     = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (class_to_search)));
10694                 }
10695             }
10696           lc = 0;
10697         }
10698
10699       /* NAME is a simple identifier or comes from a primary. Search
10700          in the class whose declaration contain the method being
10701          invoked. */
10702       resolve_and_layout (class_to_search, NULL_TREE);
10703
10704       list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
10705       /* Don't continue if no method were found, as the next statement
10706          can't be executed then. */
10707       if (!list)
10708         PATCH_METHOD_RETURN_ERROR ();
10709
10710       if (TYPE_ARRAY_P (class_to_search)
10711           && DECL_NAME (list) == get_identifier ("clone"))
10712         is_array_clone_call = 1;
10713
10714       /* Check for static reference of non static methods.  */
10715       if (check_for_static_method_reference (wfl, patch, list,
10716                                              class_to_search, primary))
10717         PATCH_METHOD_RETURN_ERROR ();
10718
10719       /* Check for inner classes creation from illegal contexts */
10720       if (lc && (INNER_CLASS_TYPE_P (class_to_search)
10721                  && !CLASS_STATIC (TYPE_NAME (class_to_search)))
10722           && INNER_ENCLOSING_SCOPE_CHECK (class_to_search)
10723           && !DECL_INIT_P (current_function_decl))
10724         {
10725           parse_error_context
10726             (wfl, "No enclosing instance for inner class %qs is in scope%s",
10727              lang_printable_name (class_to_search, 0),
10728              (!current_this ? "" :
10729               "; an explicit one must be provided when creating this inner class"));
10730           PATCH_METHOD_RETURN_ERROR ();
10731         }
10732
10733       /* Non static methods are called with the current object extra
10734          argument.  If PATCH is a `new TYPE()', the argument is the value
10735          returned by the object allocator.  If method is resolved as a
10736          primary, use the primary otherwise use the current THIS. */
10737       args = nreverse (args);
10738       if (TREE_CODE (patch) != NEW_CLASS_EXPR)
10739         {
10740           this_arg = primary ? primary : current_this;
10741
10742           /* If we're using an access method, things are different.
10743              There are two family of cases:
10744
10745              1) We're not generating bytecodes:
10746
10747              - LIST is non-static.  Its invocation is transformed from
10748                x(a1,...,an) into this$<n>.x(a1,....an).
10749              - LIST is static.  Its invocation is transformed from
10750                x(a1,...,an) into TYPE_OF(this$<n>).x(a1,....an)
10751
10752              2) We're generating bytecodes:
10753
10754              - LIST is non-static.  Its invocation is transformed from
10755                x(a1,....,an) into access$<n>(this$<n>,a1,...,an).
10756              - LIST is static.  Its invocation is transformed from
10757                x(a1,....,an) into TYPE_OF(this$<n>).x(a1,....an).
10758
10759              Of course, this$<n> can be arbitrarily complex, ranging from
10760              this$0 (the immediate outer context) to
10761              access$0(access$0(...(this$0))).
10762
10763              maybe_use_access_method returns a nonzero value if the
10764              this_arg has to be moved into the (then generated) stub
10765              argument list.  In the meantime, the selected function
10766              might have been replaced by a generated stub.  */
10767           if (METHOD_STATIC (list))
10768             maybe_use_access_method (0, &list, NULL);
10769           else if (!primary &&
10770                    maybe_use_access_method (is_super_init, &list, &this_arg))
10771             {
10772               args = tree_cons (NULL_TREE, this_arg, args);
10773               this_arg = NULL_TREE; /* So it doesn't get chained twice */
10774             }
10775         }
10776     }
10777
10778   /* Merge point of all resolution schemes. If we have nothing, this
10779      is an error, already signaled */
10780   if (!list)
10781     PATCH_METHOD_RETURN_ERROR ();
10782
10783   /* Check accessibility, position the is_static flag, build and
10784      return the call */
10785   if (not_accessible_p (DECL_CONTEXT (current_function_decl), list,
10786                         (primary ? TREE_TYPE (TREE_TYPE (primary)) :
10787                          NULL_TREE), from_super)
10788       /* Calls to clone() on array types are permitted as a special-case. */
10789       && !is_array_clone_call)
10790     {
10791       const char *const fct_name = IDENTIFIER_POINTER (DECL_NAME (list));
10792       const char *const access =
10793         accessibility_string (get_access_flags_from_decl (list));
10794       const char *const klass =
10795         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (list))));
10796       const char *const refklass =
10797         IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class)));
10798       const char *const what = (DECL_CONSTRUCTOR_P (list)
10799                                 ? "constructor" : "method");
10800       parse_error_context (wfl,
10801                            "Can't access %s %s %<%s.%s%> from %qs",
10802                            access, what, klass, fct_name, refklass);
10803       PATCH_METHOD_RETURN_ERROR ();
10804     }
10805
10806   /* Deprecation check: check whether the method being invoked or the
10807      instance-being-created's type are deprecated.  */
10808   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
10809     check_deprecation (wfl, TYPE_NAME (DECL_CONTEXT (list)));
10810   check_deprecation (wfl, list);
10811
10812   /* If invoking a innerclass constructor, there are hidden parameters
10813      to pass */
10814   if (TREE_CODE (patch) == NEW_CLASS_EXPR
10815       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10816     {
10817       /* And make sure we add the accessed local variables to be saved
10818          in field aliases. */
10819       args = build_alias_initializer_parameter_list
10820         (AIPL_FUNCTION_CTOR_INVOCATION, DECL_CONTEXT (list), args, NULL);
10821
10822       /* Secretly pass the current_this/primary as a second argument */
10823       if (primary || current_this)
10824         {
10825           tree extra_arg;
10826           tree this_type = (current_this ?
10827                             TREE_TYPE (TREE_TYPE (current_this)) : NULL_TREE);
10828           /* Method's (list) enclosing context */
10829           tree mec = DECL_CONTEXT (TYPE_NAME (DECL_CONTEXT (list)));
10830           /* If we have a primary, use it. */
10831           if (primary)
10832             extra_arg = primary;
10833           /* The current `this' is an inner class but isn't a direct
10834              enclosing context for the inner class we're trying to
10835              create. Build an access to the proper enclosing context
10836              and use it. */
10837           else if (current_this && PURE_INNER_CLASS_TYPE_P (this_type)
10838                    && this_type != TREE_TYPE (mec))
10839             {
10840
10841               extra_arg = build_access_to_thisn (current_class,
10842                                                  TREE_TYPE (mec), 0);
10843               extra_arg = java_complete_tree (extra_arg);
10844             }
10845           /* Otherwise, just use the current `this' as an enclosing
10846              context. */
10847           else
10848             extra_arg = current_this;
10849           args = tree_cons (NULL_TREE, extra_arg, args);
10850         }
10851       else
10852         args = tree_cons (NULL_TREE, integer_zero_node, args);
10853     }
10854
10855   /* This handles the situation where a constructor invocation needs
10856      to have an enclosing context passed as a second parameter (the
10857      constructor is one of an inner class). */
10858   if ((is_super_init ||
10859        (TREE_CODE (patch) == CALL_EXPR && name == this_identifier_node))
10860       && PURE_INNER_CLASS_TYPE_P (DECL_CONTEXT (list)))
10861     {
10862       tree dest = TYPE_NAME (DECL_CONTEXT (list));
10863       tree extra_arg =
10864         build_access_to_thisn (current_class, DECL_CONTEXT (dest), 0);
10865       extra_arg = java_complete_tree (extra_arg);
10866       args = tree_cons (NULL_TREE, extra_arg, args);
10867     }
10868
10869   is_static_flag = METHOD_STATIC (list);
10870   if (! is_static_flag && this_arg != NULL_TREE)
10871     args = tree_cons (NULL_TREE, this_arg, args);
10872
10873   /* In the context of an explicit constructor invocation, we can't
10874      invoke any method relying on `this'. Exceptions are: we're
10875      invoking a static function, primary exists and is not the current
10876      this, we're creating a new object. */
10877   if (ctxp->explicit_constructor_p
10878       && !is_static_flag
10879       && (!primary || primary == current_this)
10880       && (TREE_CODE (patch) != NEW_CLASS_EXPR))
10881     {
10882       parse_error_context (wfl, "Can't reference %<this%> before the superclass constructor has been called");
10883       PATCH_METHOD_RETURN_ERROR ();
10884     }
10885   java_parser_context_restore_global ();
10886   if (is_static)
10887     *is_static = is_static_flag;
10888   /* Sometimes, we want the decl of the selected method. Such as for
10889      EH checking */
10890   if (ret_decl)
10891     *ret_decl = list;
10892   patch = patch_invoke (patch, list, args);
10893
10894   /* Now is a good time to insert the call to finit$ */
10895   if (is_super_init && CLASS_HAS_FINIT_P (current_class))
10896     {
10897       tree finit_parms, finit_call;
10898
10899       /* Prepare to pass hidden parameters to finit$, if any. */
10900       finit_parms = build_alias_initializer_parameter_list
10901         (AIPL_FUNCTION_FINIT_INVOCATION, current_class, NULL_TREE, NULL);
10902
10903       finit_call =
10904         build_method_invocation (build_wfl_node (finit_identifier_node),
10905                                  finit_parms);
10906
10907       /* Generate the code used to initialize fields declared with an
10908          initialization statement and build a compound statement along
10909          with the super constructor invocation. */
10910       CAN_COMPLETE_NORMALLY (patch) = 1;
10911       patch = build2 (COMPOUND_EXPR, void_type_node, patch,
10912                       java_complete_tree (finit_call));
10913     }
10914   return patch;
10915 }
10916
10917 /* Check that we're not trying to do a static reference to a method in
10918    non static method. Return 1 if it's the case, 0 otherwise. */
10919
10920 static int
10921 check_for_static_method_reference (tree wfl, tree node, tree method,
10922                                    tree where, tree primary)
10923 {
10924   if (METHOD_STATIC (current_function_decl)
10925       && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
10926     {
10927       char *fct_name = xstrdup (lang_printable_name (method, 0));
10928       parse_error_context
10929         (wfl, "Can't make static reference to method %<%s %s%> in class %qs",
10930          lang_printable_name (TREE_TYPE (TREE_TYPE (method)), 0), fct_name,
10931          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
10932       free (fct_name);
10933       return 1;
10934     }
10935   return 0;
10936 }
10937
10938 /* Fix the invocation of *MDECL if necessary in the case of an
10939    invocation across a nested class.  *THIS_ARG might be modified
10940    appropriately and an alternative access to *MDECL might be
10941    returned.  */
10942
10943 static int
10944 maybe_use_access_method (int is_super_init, tree *mdecl, tree *this_arg)
10945 {
10946   tree ctx;
10947   tree md = *mdecl, ta = NULL_TREE;
10948   int to_return = 0;
10949   int non_static_context = !METHOD_STATIC (md);
10950
10951   if (is_super_init
10952       || DECL_FINIT_P (md)
10953       || DECL_INSTINIT_P (md)
10954       || !nested_member_access_p (current_class, md))
10955     return 0;
10956
10957   /* If we're calling a method found in an enclosing class, generate
10958      what it takes to retrieve the right `this'.  Don't do that if we're
10959      invoking a static method.  Note that if MD's type is unrelated to
10960      CURRENT_CLASS, then the current this can be used. */
10961
10962   if (non_static_context
10963       && !inherits_from_p (current_class, DECL_CONTEXT (md))
10964       && DECL_CONTEXT (TYPE_NAME (current_class)))
10965     {
10966       ta = *this_arg;
10967       ctx = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current_class)));
10968       if (inherits_from_p (ctx, DECL_CONTEXT (md)))
10969         {
10970           ta = build_current_thisn (current_class);
10971           ta = build_wfl_node (ta);
10972         }
10973       else
10974         {
10975           tree type = ctx;
10976           while (type)
10977             {
10978               maybe_build_thisn_access_method (type);
10979               if (inherits_from_p (type, DECL_CONTEXT (md)))
10980                 {
10981                   ta = build_access_to_thisn (ctx, type, 0);
10982                   break;
10983                 }
10984               type = (DECL_CONTEXT (TYPE_NAME (type)) ?
10985                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type))) : NULL_TREE);
10986             }
10987         }
10988       ta = java_complete_tree (ta);
10989     }
10990
10991   /* We might have to use an access method to get to MD. We can
10992      break the method access rule as long as we're not generating
10993      bytecode.  */
10994   if (METHOD_PRIVATE (md) && flag_emit_class_files)
10995     {
10996       md = build_nested_method_access_method (md);
10997       to_return = 1;
10998     }
10999
11000   *mdecl = md;
11001   if (this_arg)
11002     *this_arg = ta;
11003
11004   /* Returning a nonzero value indicates we were doing a non static
11005      method invocation that is now a static invocation. It will have
11006      callee displace `this' to insert it in the regular argument
11007      list. */
11008   return (non_static_context && to_return);
11009 }
11010
11011 /* Patch an invoke expression METHOD and ARGS, based on its invocation
11012    mode.  */
11013
11014 static tree
11015 patch_invoke (tree patch, tree method, tree args)
11016 {
11017   tree dtable, func;
11018   tree original_call, t, ta;
11019   tree check = NULL_TREE;
11020
11021   /* Last step for args: convert build-in types. If we're dealing with
11022      a new TYPE() type call, the first argument to the constructor
11023      isn't found in the incoming argument list, but delivered by
11024      `new' */
11025   t = TYPE_ARG_TYPES (TREE_TYPE (method));
11026   if (TREE_CODE (patch) == NEW_CLASS_EXPR)
11027     t = TREE_CHAIN (t);
11028   for (ta = args; t != end_params_node && ta;
11029        t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
11030     if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
11031         TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
11032       TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
11033
11034   /* Resolve unresolved returned type issues */
11035   t = TREE_TYPE (TREE_TYPE (method));
11036   if (TREE_CODE (t) == POINTER_TYPE && !CLASS_LOADED_P (TREE_TYPE (t)))
11037     resolve_and_layout (TREE_TYPE (t), NULL);
11038
11039   if (flag_emit_class_files)
11040     func = method;
11041   else
11042     {
11043       switch (invocation_mode (method, CALL_USING_SUPER (patch)))
11044         {
11045         case INVOKE_VIRTUAL:
11046           {
11047             tree signature = build_java_signature (TREE_TYPE (method));
11048             tree special;
11049             maybe_rewrite_invocation (&method, &args, &signature, &special);
11050
11051             dtable = invoke_build_dtable (0, args);
11052             func = build_invokevirtual (dtable, method, special);
11053           }
11054           break;
11055
11056         case INVOKE_NONVIRTUAL:
11057           /* If the object for the method call is null, we throw an
11058              exception.  We don't do this if the object is the current
11059              method's `this'.  In other cases we just rely on an
11060              optimization pass to eliminate redundant checks.  */
11061           if (TREE_VALUE (args) != current_this)
11062             {
11063               /* We use a save_expr here to make sure we only evaluate
11064                  the new `self' expression once.  */
11065               tree save_arg = save_expr (TREE_VALUE (args));
11066               TREE_VALUE (args) = save_arg;
11067               check = java_check_reference (save_arg, 1);
11068             }
11069           /* Fall through.  */
11070
11071         case INVOKE_SUPER:
11072         case INVOKE_STATIC:
11073           {
11074             tree signature = build_java_signature (TREE_TYPE (method));
11075             tree special;
11076             maybe_rewrite_invocation (&method, &args, &signature, &special);
11077             func = build_known_method_ref (method, TREE_TYPE (method),
11078                                            DECL_CONTEXT (method),
11079                                            signature, args, special);
11080           }
11081           break;
11082
11083         case INVOKE_INTERFACE:
11084           dtable = invoke_build_dtable (1, args);
11085           func = build_invokeinterface (dtable, method);
11086           break;
11087
11088         default:
11089           abort ();
11090         }
11091
11092       /* Ensure self_type is initialized, (invokestatic). FIXME */
11093       func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
11094     }
11095
11096   TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
11097   TREE_OPERAND (patch, 0) = func;
11098   TREE_OPERAND (patch, 1) = args;
11099   patch = check_for_builtin (method, patch);
11100   original_call = patch;
11101
11102   /* We're processing a `new TYPE ()' form. New is called and its
11103      returned value is the first argument to the constructor. We build
11104      a COMPOUND_EXPR and use saved expression so that the overall NEW
11105      expression value is a pointer to a newly created and initialized
11106      class. */
11107   if (TREE_CODE (original_call) == NEW_CLASS_EXPR)
11108     {
11109       tree class = DECL_CONTEXT (method);
11110       tree c1, saved_new, new;
11111       tree alloc_node;
11112
11113       if (flag_emit_class_files)
11114         {
11115           TREE_TYPE (patch) = build_pointer_type (class);
11116           return patch;
11117         }
11118       if (!TYPE_SIZE (class))
11119         safe_layout_class (class);
11120       alloc_node =
11121         (class_has_finalize_method (class) ? alloc_object_node
11122                                            : alloc_no_finalizer_node);
11123       new = build3 (CALL_EXPR, promote_type (class),
11124                     build_address_of (alloc_node),
11125                     build_tree_list (NULL_TREE, build_class_ref (class)),
11126                     NULL_TREE);
11127       saved_new = save_expr (new);
11128       c1 = build_tree_list (NULL_TREE, saved_new);
11129       TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
11130       TREE_OPERAND (original_call, 1) = c1;
11131       TREE_SET_CODE (original_call, CALL_EXPR);
11132       patch = build2 (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
11133     }
11134
11135   /* If CHECK is set, then we are building a check to see if the object
11136      is NULL.  */
11137   if (check != NULL_TREE)
11138     {
11139       /* We have to call force_evaluation_order now because creating a
11140          COMPOUND_EXPR wraps the arg list in a way that makes it
11141          unrecognizable by force_evaluation_order later.  Yuk.  */
11142       patch = build2 (COMPOUND_EXPR, TREE_TYPE (patch), check,
11143                       force_evaluation_order (patch));
11144       TREE_SIDE_EFFECTS (patch) = 1;
11145     }
11146
11147   /* In order to be able to modify PATCH later, we SAVE_EXPR it and
11148      put it as the first expression of a COMPOUND_EXPR. The second
11149      expression being an empty statement to be later patched if
11150      necessary. We remember a TREE_LIST (the PURPOSE is the method,
11151      the VALUE is the compound) in a hashtable and return a
11152      COMPOUND_EXPR built so that the result of the evaluation of the
11153      original PATCH node is returned. */
11154   if (STATIC_CLASS_INIT_OPT_P ()
11155       && current_function_decl && METHOD_STATIC (method))
11156     {
11157       tree list;
11158       tree fndecl = current_function_decl;
11159       /* We have to call force_evaluation_order now because creating a
11160          COMPOUND_EXPR wraps the arg list in a way that makes it
11161          unrecognizable by force_evaluation_order later.  Yuk.  */
11162       tree save = force_evaluation_order (patch);
11163       tree type = TREE_TYPE (patch);
11164
11165       patch = build2 (COMPOUND_EXPR, type, save, build_java_empty_stmt ());
11166       list = tree_cons (method, patch,
11167                         DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl));
11168
11169       DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = list;
11170
11171       patch = build2 (COMPOUND_EXPR, type, patch, save);
11172     }
11173
11174   return patch;
11175 }
11176
11177 static int
11178 invocation_mode (tree method, int super)
11179 {
11180   int access = get_access_flags_from_decl (method);
11181
11182   if (super)
11183     return INVOKE_SUPER;
11184
11185   if (access & ACC_STATIC)
11186     return INVOKE_STATIC;
11187
11188   /* We have to look for a constructor before we handle nonvirtual
11189      calls; otherwise the constructor will look nonvirtual.  */
11190   if (DECL_CONSTRUCTOR_P (method))
11191     return INVOKE_STATIC;
11192
11193   if (access & ACC_PRIVATE)
11194     return INVOKE_NONVIRTUAL;
11195
11196   /* Binary compatibility: just because it's final today, that doesn't
11197      mean it'll be final tomorrow.  */
11198   if (! flag_indirect_dispatch
11199       || DECL_CONTEXT (method) == object_type_node)
11200     {
11201       if (access & ACC_FINAL)
11202         return INVOKE_NONVIRTUAL;
11203
11204       if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
11205         return INVOKE_NONVIRTUAL;
11206     }
11207
11208   if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
11209     return INVOKE_INTERFACE;
11210
11211   return INVOKE_VIRTUAL;
11212 }
11213
11214 /* Retrieve a refined list of matching methods. It covers the step
11215    15.11.2 (Compile-Time Step 2) */
11216
11217 static tree
11218 lookup_method_invoke (int lc, tree cl, tree class, tree name, tree arg_list)
11219 {
11220   tree atl = end_params_node;           /* Arg Type List */
11221   tree method, signature, list, node;
11222   const char *candidates;               /* Used for error report */
11223   char *dup;
11224
11225   /* Fix the arguments */
11226   for (node = arg_list; node; node = TREE_CHAIN (node))
11227     {
11228       tree current_arg = TREE_TYPE (TREE_VALUE (node));
11229       /* Non primitive type may have to be resolved */
11230       if (!JPRIMITIVE_TYPE_P (current_arg))
11231         resolve_and_layout (current_arg, NULL_TREE);
11232       /* And promoted */
11233       if (TREE_CODE (current_arg) == RECORD_TYPE)
11234         current_arg = promote_type (current_arg);
11235       /* If we're building an anonymous constructor call, and one of
11236          the arguments has array type, cast it to a size-less array
11237          type.  This prevents us from getting a strange gcj-specific
11238          "sized array" signature in the constructor's signature.  */
11239       if (lc && ANONYMOUS_CLASS_P (class)
11240           && TREE_CODE (current_arg) == POINTER_TYPE
11241           && TYPE_ARRAY_P (TREE_TYPE (current_arg)))
11242         {
11243           tree elt = TYPE_ARRAY_ELEMENT (TREE_TYPE (current_arg));
11244           current_arg = build_pointer_type (build_java_array_type (elt, -1));
11245         }
11246       atl = tree_cons (NULL_TREE, current_arg, atl);
11247     }
11248
11249   /* Presto. If we're dealing with an anonymous class and a
11250      constructor call, generate the right constructor now, since we
11251      know the arguments' types. */
11252
11253   if (lc && ANONYMOUS_CLASS_P (class))
11254     {
11255       tree mdecl = craft_constructor (TYPE_NAME (class), atl);
11256       /* The anonymous class may have already been laid out, so make sure
11257          the new constructor is laid out here.  */
11258       layout_class_method (class, CLASSTYPE_SUPER (class), mdecl, NULL_TREE);
11259     }
11260
11261   /* Find all candidates and then refine the list, searching for the
11262      most specific method. */
11263   list = find_applicable_accessible_methods_list (lc, class, name, atl);
11264   list = find_most_specific_methods_list (list, class);
11265   if (list && !TREE_CHAIN (list))
11266     return TREE_VALUE (list);
11267
11268   /* Issue an error. List candidates if any. Candidates are listed
11269      only if accessible (non accessible methods may end-up here for
11270      the sake of a better error report). */
11271   candidates = NULL;
11272   if (list)
11273     {
11274       tree current;
11275       obstack_grow (&temporary_obstack, ". Candidates are:\n", 18);
11276       for (current = list; current; current = TREE_CHAIN (current))
11277         {
11278           tree cm = TREE_VALUE (current);
11279           char string [4096];
11280           if (!cm || not_accessible_p (class, cm, NULL_TREE, 0))
11281             continue;
11282           sprintf
11283             (string, "  '%s' in '%s'%s",
11284              get_printable_method_name (cm),
11285              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (cm)))),
11286              (TREE_CHAIN (current) ? "\n" : ""));
11287           obstack_grow (&temporary_obstack, string, strlen (string));
11288         }
11289       obstack_1grow (&temporary_obstack, '\0');
11290       candidates = obstack_finish (&temporary_obstack);
11291     }
11292   /* Issue the error message */
11293   method = make_node (FUNCTION_TYPE);
11294   TYPE_ARG_TYPES (method) = atl;
11295   signature = build_java_argument_signature (method);
11296   dup = xstrdup (lang_printable_name (class, 0));
11297   parse_error_context (cl, "Can't find %s %<%s(%s)%> in type %qs%s",
11298                        (lc ? "constructor" : "method"),
11299                        (lc ? dup : IDENTIFIER_POINTER (name)),
11300                        IDENTIFIER_POINTER (signature), dup,
11301                        (candidates ? candidates : ""));
11302   free (dup);
11303   return NULL_TREE;
11304 }
11305
11306 /* 15.11.2.1: Find Methods that are Applicable and Accessible. LC is 1
11307    when we're looking for a constructor. */
11308
11309 static tree
11310 find_applicable_accessible_methods_list (int lc, tree class, tree name,
11311                                          tree arglist)
11312 {
11313   static htab_t searched_classes;
11314   static int search_not_done = 0;
11315   tree list = NULL_TREE, all_list = NULL_TREE;
11316   tree base_binfo;
11317   int i;
11318
11319   /* Check the hash table to determine if this class has been searched
11320      already. */
11321   if (searched_classes)
11322     {
11323       if (htab_find (searched_classes, class) != NULL)
11324         return NULL;
11325     }
11326   else
11327     {
11328       searched_classes = htab_create (10, htab_hash_pointer,
11329                                       htab_eq_pointer, NULL);
11330     }
11331
11332   search_not_done++;
11333   *htab_find_slot (searched_classes, class, INSERT) = class;
11334
11335   if (!CLASS_LOADED_P (class))
11336     {
11337       load_class (class, 1);
11338       safe_layout_class (class);
11339     }
11340
11341   /* Search interfaces */
11342   if (TREE_CODE (TYPE_NAME (class)) == TYPE_DECL
11343       && CLASS_INTERFACE (TYPE_NAME (class)))
11344     {
11345       search_applicable_methods_list (lc, TYPE_METHODS (class),
11346                                       name, arglist, &list, &all_list);
11347       for (i = 1; BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
11348         {
11349           tree t = BINFO_TYPE (base_binfo);
11350           tree rlist;
11351
11352           rlist = find_applicable_accessible_methods_list (lc,  t, name,
11353                                                            arglist);
11354           list = chainon (rlist, list);
11355         }
11356     }
11357   /* Search classes */
11358   else
11359     {
11360       search_applicable_methods_list (lc, TYPE_METHODS (class),
11361                                       name, arglist, &list, &all_list);
11362
11363       /* When looking finit$, class$ or instinit$, we turn LC to 1 so
11364          that we only search in class. Note that we should have found
11365          something at this point. */
11366       if (ID_FINIT_P (name) || ID_CLASSDOLLAR_P (name) || ID_INSTINIT_P (name))
11367         {
11368           lc = 1;
11369           if (!list)
11370             abort ();
11371         }
11372
11373       /* We must search all interfaces of this class */
11374       if (!lc)
11375         {
11376           for (i = 1;
11377                BINFO_BASE_ITERATE (TYPE_BINFO (class), i, base_binfo); i++)
11378             {
11379               tree t = BINFO_TYPE (base_binfo);
11380               if (t != object_type_node)
11381                 {
11382                   tree rlist
11383                     = find_applicable_accessible_methods_list (lc, t,
11384                                                                name, arglist);
11385                   list = chainon (rlist, list);
11386                 }
11387             }
11388         }
11389
11390       /* Search superclass */
11391       if (!lc && CLASSTYPE_SUPER (class) != NULL_TREE)
11392         {
11393           tree rlist;
11394           class = CLASSTYPE_SUPER (class);
11395           rlist = find_applicable_accessible_methods_list (lc, class,
11396                                                            name, arglist);
11397           list = chainon (rlist, list);
11398         }
11399     }
11400
11401   search_not_done--;
11402
11403   /* We're done. Reset the searched classes list and finally search
11404      java.lang.Object if it wasn't searched already. */
11405   if (!search_not_done)
11406     {
11407       if (!lc
11408           && TYPE_METHODS (object_type_node)
11409           && htab_find (searched_classes, object_type_node) == NULL)
11410         {
11411           search_applicable_methods_list (lc,
11412                                           TYPE_METHODS (object_type_node),
11413                                           name, arglist, &list, &all_list);
11414         }
11415       htab_delete (searched_classes);
11416       searched_classes = NULL;
11417     }
11418
11419   /* Either return the list obtained or all selected (but
11420      inaccessible) methods for better error report. */
11421   return (!list ? all_list : list);
11422 }
11423
11424 /* Effectively search for the appropriate method in method */
11425
11426 static void
11427 search_applicable_methods_list (int lc, tree method, tree name, tree arglist,
11428                                 tree *list, tree *all_list)
11429 {
11430   for (; method; method = TREE_CHAIN (method))
11431     {
11432       /* When dealing with constructor, stop here, otherwise search
11433          other classes */
11434       if (lc && !DECL_CONSTRUCTOR_P (method))
11435         continue;
11436       else if (!lc && (DECL_CONSTRUCTOR_P (method)
11437                        || (DECL_NAME (method) != name)))
11438         continue;
11439
11440       if (argument_types_convertible (method, arglist))
11441         {
11442           /* Retain accessible methods only */
11443           if (!not_accessible_p (DECL_CONTEXT (current_function_decl),
11444                                  method, NULL_TREE, 0))
11445             *list = tree_cons (NULL_TREE, method, *list);
11446           else
11447             /* Also retain all selected method here */
11448             *all_list = tree_cons (NULL_TREE, method, *list);
11449         }
11450     }
11451 }
11452
11453 /* 15.11.2.2 Choose the Most Specific Method */
11454
11455 static tree
11456 find_most_specific_methods_list (tree list, tree class)
11457 {
11458   int max = 0;
11459   int abstract, candidates;
11460   tree current, new_list = NULL_TREE;
11461   for (current = list; current; current = TREE_CHAIN (current))
11462     {
11463       tree method;
11464       DECL_SPECIFIC_COUNT (TREE_VALUE (current)) = 0;
11465
11466       for (method = list; method; method = TREE_CHAIN (method))
11467         {
11468           tree method_v, current_v;
11469           /* Don't test a method against itself */
11470           if (method == current)
11471             continue;
11472
11473           method_v = TREE_VALUE (method);
11474           current_v = TREE_VALUE (current);
11475
11476           /* Compare arguments and location where methods where declared */
11477           if (argument_types_convertible (method_v, current_v))
11478             {
11479               /* We have a rather odd special case here.  The front
11480                  end doesn't properly implement inheritance, so we
11481                  work around it here.  The idea is, if we are
11482                  comparing a method declared in a class to one
11483                  declared in an interface, and the invocation's
11484                  qualifying class is a class (and not an interface),
11485                  then we consider the method's class to be the
11486                  qualifying class of the invocation.  This lets us
11487                  fake the result of ordinary inheritance.  */
11488               tree context_v = DECL_CONTEXT (current_v);
11489               if (TYPE_INTERFACE_P (DECL_CONTEXT (method_v))
11490                   && ! TYPE_INTERFACE_P (context_v)
11491                   && ! TYPE_INTERFACE_P (class))
11492                 context_v = class;
11493
11494               if (valid_method_invocation_conversion_p
11495                   (DECL_CONTEXT (method_v), context_v))
11496                 {
11497                   int v = (DECL_SPECIFIC_COUNT (current_v) += 1);
11498                   max = (v > max ? v : max);
11499                 }
11500             }
11501         }
11502     }
11503
11504   /* Review the list and select the maximally specific methods */
11505   for (current = list, abstract = -1, candidates = -1;
11506        current; current = TREE_CHAIN (current))
11507     if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11508       {
11509         new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11510         abstract += (METHOD_ABSTRACT (TREE_VALUE (current)) ? 1 : 0);
11511         candidates++;
11512       }
11513
11514   /* If we have several and they're all abstract, just pick the
11515      closest one. */
11516   if (candidates > 0 && candidates == abstract)
11517     {
11518       /* FIXME: merge the throws clauses.  There is no convenient way
11519          to do this in gcj right now, since ideally we'd like to
11520          introduce a new METHOD_DECL here, but that is really not
11521          possible.  */
11522       new_list = nreverse (new_list);
11523       TREE_CHAIN (new_list) = NULL_TREE;
11524       return new_list;
11525     }
11526
11527   /* We have several (we couldn't find a most specific), all but one
11528      are abstract, we pick the only non abstract one. */
11529   if (candidates > 0 && (candidates == abstract+1))
11530     {
11531       for (current = new_list; current; current = TREE_CHAIN (current))
11532         if (!METHOD_ABSTRACT (TREE_VALUE (current)))
11533           {
11534             TREE_CHAIN (current) = NULL_TREE;
11535             new_list = current;
11536           }
11537     }
11538
11539   /* If we can't find one, lower expectations and try to gather multiple
11540      maximally specific methods */
11541   while (!new_list && max)
11542     {
11543       while (--max > 0)
11544         {
11545           if (DECL_SPECIFIC_COUNT (TREE_VALUE (current)) == max)
11546             new_list = tree_cons (NULL_TREE, TREE_VALUE (current), new_list);
11547         }
11548     }
11549
11550   return new_list;
11551 }
11552
11553 /* Make sure that the type of each M2_OR_ARGLIST arguments can be
11554    converted by method invocation conversion (5.3) to the type of the
11555    corresponding parameter of M1. Implementation expects M2_OR_ARGLIST
11556    to change less often than M1. */
11557
11558 static GTY(()) tree m2_arg_value;
11559 static GTY(()) tree m2_arg_cache;
11560
11561 static int
11562 argument_types_convertible (tree m1, tree m2_or_arglist)
11563 {
11564   tree m1_arg, m2_arg;
11565
11566   SKIP_THIS_AND_ARTIFICIAL_PARMS (m1_arg, m1)
11567
11568   if (m2_arg_value == m2_or_arglist)
11569     m2_arg = m2_arg_cache;
11570   else
11571     {
11572       /* M2_OR_ARGLIST can be a function DECL or a raw list of
11573          argument types */
11574       if (m2_or_arglist && TREE_CODE (m2_or_arglist) == FUNCTION_DECL)
11575         {
11576           m2_arg = TYPE_ARG_TYPES (TREE_TYPE (m2_or_arglist));
11577           if (!METHOD_STATIC (m2_or_arglist))
11578             m2_arg = TREE_CHAIN (m2_arg);
11579         }
11580       else
11581         m2_arg = m2_or_arglist;
11582
11583       m2_arg_value = m2_or_arglist;
11584       m2_arg_cache = m2_arg;
11585     }
11586
11587   while (m1_arg != end_params_node && m2_arg != end_params_node)
11588     {
11589       resolve_and_layout (TREE_VALUE (m1_arg), NULL_TREE);
11590       if (!valid_method_invocation_conversion_p (TREE_VALUE (m1_arg),
11591                                                  TREE_VALUE (m2_arg)))
11592         break;
11593       m1_arg = TREE_CHAIN (m1_arg);
11594       m2_arg = TREE_CHAIN (m2_arg);
11595     }
11596   return m1_arg == end_params_node && m2_arg == end_params_node;
11597 }
11598
11599 /* Qualification routines */
11600
11601 /* Given a name x.y.z, look up x locally.  If it's found, save the
11602    decl.  If it's not found, mark the name as RESOLVE_PACKAGE_NAME_P,
11603    so that we later try and load the appropriate classes.  */
11604 static void
11605 qualify_ambiguous_name (tree id)
11606 {
11607   tree name, decl;
11608
11609   /* We inspect the first item of the qualification list.  As a sanity
11610      check, make sure that it is an identfier node.  */
11611   tree qual = EXPR_WFL_QUALIFICATION (id);
11612   tree qual_wfl = QUAL_WFL (qual);
11613
11614   if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
11615     return;
11616
11617   name = EXPR_WFL_NODE (qual_wfl);
11618
11619   /* If we don't have an identifier, or we have a 'this' or 'super',
11620      then field access processing is all we need : there is nothing
11621      for us to do.  */
11622   if (!name || TREE_CODE (name) != IDENTIFIER_NODE ||
11623       name == this_identifier_node ||
11624       name == super_identifier_node)
11625     return;
11626
11627   /* If name appears within the scope of a local variable declaration
11628      or parameter declaration, or is a field within an enclosing
11629      class, then it is an expression name.  Save the decl and let
11630      resolve_field_access do it's work.  */
11631   if ((decl = IDENTIFIER_LOCAL_VALUE (name)) ||
11632       (decl = lookup_field_wrapper (current_class, name)))
11633     {
11634       QUAL_RESOLUTION (qual) = decl;
11635       return;
11636     }
11637
11638   /* If name is a known class name (either declared or imported), mark
11639      us as a type name.  */
11640   if ((decl = resolve_and_layout (name, NULL_TREE)))
11641     {
11642       RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
11643       QUAL_RESOLUTION (qual) = decl;
11644     }
11645
11646   /* Check here that NAME isn't declared by more than one
11647      type-import-on-demand declaration of the compilation unit
11648      containing NAME. FIXME */
11649
11650   /* We couldn't find a declaration for the name.  Assume for now that
11651      we have a qualified class name that needs to be loaded from an
11652      external class file.  */
11653   else
11654     RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
11655
11656   /* Propagate the qualification across other components of the
11657      qualified name */
11658   for (qual = TREE_CHAIN (qual); qual;
11659        qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
11660     {
11661       if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11662         RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
11663     }
11664
11665   /* Store the global qualification for the ambiguous part of ID back
11666      into ID fields */
11667   if (RESOLVE_TYPE_NAME_P (qual_wfl))
11668     RESOLVE_TYPE_NAME_P (id) = 1;
11669   else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
11670     RESOLVE_PACKAGE_NAME_P (id) = 1;
11671 }
11672
11673 /* Patch tree nodes in a function body. When a BLOCK is found, push
11674    local variable decls if present.
11675    Same as java_complete_lhs, but does resolve static finals to values. */
11676
11677 static tree
11678 java_complete_tree (tree node)
11679 {
11680   node = java_complete_lhs (node);
11681   if (JDECL_P (node) && CLASS_FINAL_VARIABLE_P (node)
11682       && DECL_INITIAL (node) != NULL_TREE)
11683     {
11684       tree value = fold_constant_for_init (node, node);
11685       if (value != NULL_TREE)
11686         return value;
11687     }
11688   return node;
11689 }
11690
11691 static tree
11692 java_stabilize_reference (tree node)
11693 {
11694   if (TREE_CODE (node) == COMPOUND_EXPR)
11695     {
11696       tree op0 = TREE_OPERAND (node, 0);
11697       tree op1 = TREE_OPERAND (node, 1);
11698       TREE_OPERAND (node, 0) = save_expr (op0);
11699       TREE_OPERAND (node, 1) = java_stabilize_reference (op1);
11700       return node;
11701     }
11702   return stabilize_reference (node);
11703 }
11704
11705 /* Patch tree nodes in a function body. When a BLOCK is found, push
11706    local variable decls if present.
11707    Same as java_complete_tree, but does not resolve static finals to values. */
11708
11709 static tree
11710 java_complete_lhs (tree node)
11711 {
11712   tree nn, cn, wfl_op1, wfl_op2, wfl_op3;
11713   int flag;
11714
11715   /* CONVERT_EXPR always has its type set, even though it needs to be
11716      worked out. */
11717   if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
11718     return node;
11719
11720   /* The switch block implements cases processing container nodes
11721      first.  Contained nodes are always written back. Leaves come
11722      next and return a value. */
11723   switch (TREE_CODE (node))
11724     {
11725     case BLOCK:
11726
11727       /* 1- Block section.
11728          Set the local values on decl names so we can identify them
11729          faster when they're referenced. At that stage, identifiers
11730          are legal so we don't check for declaration errors. */
11731       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11732         {
11733           DECL_CONTEXT (cn) = current_function_decl;
11734           IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
11735         }
11736       if (BLOCK_EXPR_BODY (node) == NULL_TREE)
11737           CAN_COMPLETE_NORMALLY (node) = 1;
11738       else
11739         {
11740           tree stmt = BLOCK_EXPR_BODY (node);
11741           tree *ptr;
11742           int error_seen = 0;
11743           if (TREE_CODE (stmt) == COMPOUND_EXPR)
11744             {
11745               /* Re-order from (((A; B); C); ...; Z) to
11746                  (A; (B; (C ; (...; Z)))).
11747                  This makes it easier to scan the statements left-to-right
11748                  without using recursion (which might overflow the stack
11749                  if the block has many statements. */
11750               for (;;)
11751                 {
11752                   tree left = TREE_OPERAND (stmt, 0);
11753                   if (TREE_CODE (left) != COMPOUND_EXPR)
11754                     break;
11755                   TREE_OPERAND (stmt, 0) = TREE_OPERAND (left, 1);
11756                   TREE_OPERAND (left, 1) = stmt;
11757                   stmt = left;
11758                 }
11759               BLOCK_EXPR_BODY (node) = stmt;
11760             }
11761
11762           /* Now do the actual complete, without deep recursion for
11763              long blocks. */
11764           ptr = &BLOCK_EXPR_BODY (node);
11765           while (TREE_CODE (*ptr) == COMPOUND_EXPR
11766                  && !IS_EMPTY_STMT (TREE_OPERAND (*ptr, 1)))
11767             {
11768               tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
11769               tree *next = &TREE_OPERAND (*ptr, 1);
11770               TREE_OPERAND (*ptr, 0) = cur;
11771               if (IS_EMPTY_STMT (cur))
11772                 {
11773                   /* Optimization;  makes it easier to detect empty bodies.
11774                      Most useful for <clinit> with all-constant initializer. */
11775                   *ptr = *next;
11776                   continue;
11777                 }
11778               if (TREE_CODE (cur) == ERROR_MARK)
11779                 error_seen++;
11780               else if (! CAN_COMPLETE_NORMALLY (cur))
11781                 {
11782                   wfl_op2 = *next;
11783                   for (;;)
11784                     {
11785                       if (TREE_CODE (wfl_op2) == BLOCK)
11786                         wfl_op2 = BLOCK_EXPR_BODY (wfl_op2);
11787                       else if (TREE_CODE (wfl_op2) == COMPOUND_EXPR)
11788                         wfl_op2 = TREE_OPERAND (wfl_op2, 0);
11789                       else
11790                         break;
11791                     }
11792                   if (TREE_CODE (wfl_op2) != CASE_EXPR
11793                       && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
11794                     unreachable_stmt_error (*ptr);
11795                 }
11796               if (TREE_TYPE (*ptr) == NULL_TREE)
11797                 TREE_TYPE (*ptr) = void_type_node;
11798               ptr = next;
11799             }
11800           *ptr = java_complete_tree (*ptr);
11801
11802           if (TREE_CODE (*ptr) == ERROR_MARK || error_seen > 0)
11803             return error_mark_node;
11804           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (*ptr);
11805         }
11806       /* Turn local bindings to null */
11807       for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
11808         IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
11809
11810       TREE_TYPE (node) = void_type_node;
11811       break;
11812
11813       /* 2- They are expressions but ultimately deal with statements */
11814
11815     case THROW_EXPR:
11816       wfl_op1 = TREE_OPERAND (node, 0);
11817       COMPLETE_CHECK_OP_0 (node);
11818       /* 14.19 A throw statement cannot complete normally. */
11819       CAN_COMPLETE_NORMALLY (node) = 0;
11820       return patch_throw_statement (node, wfl_op1);
11821
11822     case SYNCHRONIZED_EXPR:
11823       wfl_op1 = TREE_OPERAND (node, 0);
11824       return patch_synchronized_statement (node, wfl_op1);
11825
11826     case TRY_EXPR:
11827       return patch_try_statement (node);
11828
11829     case TRY_FINALLY_EXPR:
11830       COMPLETE_CHECK_OP_0 (node);
11831       COMPLETE_CHECK_OP_1 (node);
11832       if (IS_EMPTY_STMT (TREE_OPERAND (node, 0)))
11833         /* Reduce try/finally nodes with an empty try block.  */
11834         return TREE_OPERAND (node, 1);
11835       if (IS_EMPTY_STMT (TREE_OPERAND (node, 1)))
11836         /* Likewise for an empty finally block.  */
11837         return TREE_OPERAND (node, 0);
11838       CAN_COMPLETE_NORMALLY (node)
11839         = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
11840            && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
11841       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 0));
11842       return node;
11843
11844     case LABELED_BLOCK_EXPR:
11845       PUSH_LABELED_BLOCK (node);
11846       if (LABELED_BLOCK_BODY (node))
11847         COMPLETE_CHECK_OP_1 (node);
11848       TREE_TYPE (node) = void_type_node;
11849       POP_LABELED_BLOCK ();
11850
11851       if (IS_EMPTY_STMT (LABELED_BLOCK_BODY (node)))
11852         {
11853           LABELED_BLOCK_BODY (node) = NULL_TREE;
11854           CAN_COMPLETE_NORMALLY (node) = 1;
11855         }
11856       else if (CAN_COMPLETE_NORMALLY (LABELED_BLOCK_BODY (node)))
11857         CAN_COMPLETE_NORMALLY (node) = 1;
11858       return node;
11859
11860     case EXIT_BLOCK_EXPR:
11861       return patch_bc_statement (node);
11862
11863     case CASE_EXPR:
11864       cn = java_complete_tree (TREE_OPERAND (node, 0));
11865       if (cn == error_mark_node)
11866         return cn;
11867
11868       /* First, the case expression must be constant. Values of final
11869          fields are accepted. */
11870       nn = fold_constant_for_init (cn, NULL_TREE);
11871       if (nn != NULL_TREE)
11872         cn = nn;
11873
11874       cn = fold (cn);
11875       if ((TREE_CODE (cn) == COMPOUND_EXPR
11876            || TREE_CODE (cn) == COMPONENT_REF)
11877           && JDECL_P (TREE_OPERAND (cn, 1))
11878           && FIELD_FINAL (TREE_OPERAND (cn, 1))
11879           && DECL_INITIAL (TREE_OPERAND (cn, 1)))
11880         {
11881           cn = fold_constant_for_init (DECL_INITIAL (TREE_OPERAND (cn, 1)),
11882                                        TREE_OPERAND (cn, 1));
11883         }
11884       /* Accept final locals too. */
11885       else if (TREE_CODE (cn) == VAR_DECL && DECL_FINAL (cn)
11886                && DECL_INITIAL (cn))
11887         cn = fold_constant_for_init (DECL_INITIAL (cn), cn);
11888
11889       if (!TREE_CONSTANT (cn))
11890         {
11891           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11892           parse_error_context (node, "Constant expression required");
11893           return error_mark_node;
11894         }
11895
11896       nn = ctxp->current_loop;
11897
11898       /* It must be assignable to the type of the switch expression. */
11899       if (!try_builtin_assignconv (NULL_TREE,
11900                                    TREE_TYPE (TREE_OPERAND (nn, 0)), cn))
11901         {
11902           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11903           parse_error_context
11904             (wfl_operator,
11905              "Incompatible type for case. Can't convert %qs to %<int%>",
11906              lang_printable_name (TREE_TYPE (cn), 0));
11907           return error_mark_node;
11908         }
11909
11910       cn = fold (convert (int_type_node, cn));
11911       TREE_CONSTANT_OVERFLOW (cn) = 0;
11912       CAN_COMPLETE_NORMALLY (cn) = 1;
11913
11914       /* Save the label on a list so that we can later check for
11915          duplicates.  */
11916       case_label_list = tree_cons (node, cn, case_label_list);
11917
11918       /* Multiple instance of a case label bearing the same value is
11919          checked later. The case expression is all right so far. */
11920       if (TREE_CODE (cn) == VAR_DECL)
11921         cn = DECL_INITIAL (cn);
11922       TREE_OPERAND (node, 0) = cn;
11923       TREE_TYPE (node) = void_type_node;
11924       CAN_COMPLETE_NORMALLY (node) = 1;
11925       TREE_SIDE_EFFECTS (node) = 1;
11926       break;
11927
11928     case DEFAULT_EXPR:
11929       nn = ctxp->current_loop;
11930       /* Only one default label is allowed per switch statement */
11931       if (SWITCH_HAS_DEFAULT (nn))
11932         {
11933 #ifdef USE_MAPPED_LOCATION
11934           SET_EXPR_LOCATION (wfl_operator, EXPR_LOCATION (node));
11935 #else
11936           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
11937 #endif
11938           parse_error_context (wfl_operator,
11939                                "Duplicate case label: %<default%>");
11940           return error_mark_node;
11941         }
11942       else
11943         SWITCH_HAS_DEFAULT (nn) = 1;
11944       TREE_TYPE (node) = void_type_node;
11945       TREE_SIDE_EFFECTS (node) = 1;
11946       CAN_COMPLETE_NORMALLY (node) = 1;
11947       break;
11948
11949     case SWITCH_EXPR:
11950     case LOOP_EXPR:
11951       PUSH_LOOP (node);
11952       /* Check whether the loop was enclosed in a labeled
11953          statement. If not, create one, insert the loop in it and
11954          return the node */
11955       nn = patch_loop_statement (node);
11956
11957       /* Anyways, walk the body of the loop */
11958       if (TREE_CODE (node) == LOOP_EXPR)
11959         TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11960       /* Switch statement: walk the switch expression and the cases */
11961       else
11962         node = patch_switch_statement (node);
11963
11964       if (node == error_mark_node || TREE_OPERAND (node, 0) == error_mark_node)
11965         nn = error_mark_node;
11966       else
11967         {
11968           TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
11969           /* If we returned something different, that's because we
11970              inserted a label. Pop the label too. */
11971           if (nn != node)
11972             {
11973               if (CAN_COMPLETE_NORMALLY (node))
11974                 CAN_COMPLETE_NORMALLY (nn) = 1;
11975               POP_LABELED_BLOCK ();
11976             }
11977         }
11978       POP_LOOP ();
11979       return nn;
11980
11981     case EXIT_EXPR:
11982       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11983       return patch_exit_expr (node);
11984
11985     case COND_EXPR:
11986       /* Condition */
11987       TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
11988       if (TREE_OPERAND (node, 0) == error_mark_node)
11989         return error_mark_node;
11990       /* then-else branches */
11991       TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
11992       if (TREE_OPERAND (node, 1) == error_mark_node)
11993         return error_mark_node;
11994       {
11995         /* This is a special case due to build_assertion().  When
11996            assertions are disabled we build a COND_EXPR in which
11997            Operand 1 is the body of the assertion.  If that happens to
11998            be a string concatenation we'll need to patch it here.  */
11999         tree patched = patch_string (TREE_OPERAND (node, 1));
12000         if (patched)
12001           TREE_OPERAND (node, 1) = patched;
12002       }
12003      TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
12004       if (TREE_OPERAND (node, 2) == error_mark_node)
12005         return error_mark_node;
12006       return patch_if_else_statement (node);
12007       break;
12008
12009     case CONDITIONAL_EXPR:
12010       /* Condition */
12011       wfl_op1 = TREE_OPERAND (node, 0);
12012       COMPLETE_CHECK_OP_0 (node);
12013       wfl_op2 = TREE_OPERAND (node, 1);
12014       COMPLETE_CHECK_OP_1 (node);
12015       wfl_op3 = TREE_OPERAND (node, 2);
12016       COMPLETE_CHECK_OP_2 (node);
12017       return patch_conditional_expr (node, wfl_op1, wfl_op2);
12018
12019       /* 3- Expression section */
12020     case COMPOUND_EXPR:
12021       wfl_op2 = TREE_OPERAND (node, 1);
12022       TREE_OPERAND (node, 0) = nn =
12023         java_complete_tree (TREE_OPERAND (node, 0));
12024       if (IS_EMPTY_STMT (wfl_op2))
12025         CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
12026       else
12027         {
12028           if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
12029             {
12030               /* An unreachable condition in a do-while statement
12031                  is *not* (technically) an unreachable statement. */
12032               nn = wfl_op2;
12033               if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
12034                 nn = EXPR_WFL_NODE (nn);
12035               /* NN can be NULL_TREE exactly when UPDATE is, in
12036                  finish_for_loop.  */
12037               if (nn != NULL_TREE && TREE_CODE (nn) != EXIT_EXPR)
12038                 {
12039                   SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
12040                   if (SUPPRESS_UNREACHABLE_ERROR (nn))
12041                     {
12042                       /* Perhaps this warning should have an
12043                          associated flag.  The code being compiled is
12044                          pedantically correct, but useless.  */
12045                       parse_warning_context (wfl_operator,
12046                                              "Unreachable statement");
12047                     }
12048                   else
12049                     parse_error_context (wfl_operator,
12050                                          "Unreachable statement");
12051                 }
12052             }
12053           TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
12054           if (TREE_OPERAND (node, 1) == error_mark_node)
12055             return error_mark_node;
12056           /* Even though we might allow the case where the first
12057              operand doesn't return normally, we still should compute
12058              CAN_COMPLETE_NORMALLY correctly.  */
12059           CAN_COMPLETE_NORMALLY (node)
12060             = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 0))
12061                && CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1)));
12062         }
12063       TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
12064       break;
12065
12066     case RETURN_EXPR:
12067       /* CAN_COMPLETE_NORMALLY (node) = 0; */
12068       return patch_return (node);
12069
12070     case EXPR_WITH_FILE_LOCATION:
12071       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
12072           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
12073         {
12074           node = resolve_expression_name (node, NULL);
12075           if (node == error_mark_node)
12076             return node;
12077           CAN_COMPLETE_NORMALLY (node) = 1;
12078         }
12079       else
12080         {
12081           tree body;
12082           location_t save_location = input_location;
12083 #ifdef USE_MAPPED_LOCATION
12084           input_location = EXPR_LOCATION (node);
12085           if (input_location == UNKNOWN_LOCATION)
12086             input_location = save_location;
12087 #else
12088           input_line = EXPR_WFL_LINENO (node);
12089 #endif
12090           body = java_complete_tree (EXPR_WFL_NODE (node));
12091           input_location = save_location;
12092           EXPR_WFL_NODE (node) = body;
12093           TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
12094           CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
12095           if (IS_EMPTY_STMT (body) || TREE_CONSTANT (body))
12096             {
12097               /* Makes it easier to constant fold, detect empty bodies. */
12098               return body;
12099             }
12100           if (body == error_mark_node)
12101             {
12102               /* Its important for the evaluation of assignment that
12103                  this mark on the TREE_TYPE is propagated. */
12104               TREE_TYPE (node) = error_mark_node;
12105               return error_mark_node;
12106             }
12107           else
12108             TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
12109
12110         }
12111       break;
12112
12113     case NEW_ARRAY_EXPR:
12114       /* Patch all the dimensions */
12115       flag = 0;
12116       for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12117         {
12118           int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
12119           tree dim = convert (int_type_node,
12120                               java_complete_tree (TREE_VALUE (cn)));
12121           if (dim == error_mark_node)
12122             {
12123               flag = 1;
12124               continue;
12125             }
12126           else
12127             {
12128               TREE_VALUE (cn) = dim;
12129               /* Setup the location of the current dimension, for
12130                  later error report. */
12131 #ifdef USE_MAPPED_LOCATION
12132               TREE_PURPOSE (cn) = expr_add_location (NULL_TREE, location, 0);
12133 #else
12134               TREE_PURPOSE (cn) =
12135                 build_expr_wfl (NULL_TREE, input_filename, 0, 0);
12136               EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
12137 #endif
12138             }
12139         }
12140       /* They complete the array creation expression, if no errors
12141          were found. */
12142       CAN_COMPLETE_NORMALLY (node) = 1;
12143       return (flag ? error_mark_node
12144               : force_evaluation_order (patch_newarray (node)));
12145
12146     case NEW_ANONYMOUS_ARRAY_EXPR:
12147       /* Create the array type if necessary. */
12148       if (ANONYMOUS_ARRAY_DIMS_SIG (node))
12149         {
12150           tree type = ANONYMOUS_ARRAY_BASE_TYPE (node);
12151           if (!(type = resolve_type_during_patch (type)))
12152             return error_mark_node;
12153           type = build_array_from_name (type, NULL_TREE,
12154                                         ANONYMOUS_ARRAY_DIMS_SIG (node), NULL);
12155           ANONYMOUS_ARRAY_BASE_TYPE (node) = build_pointer_type (type);
12156         }
12157       node = patch_new_array_init (ANONYMOUS_ARRAY_BASE_TYPE (node),
12158                                    ANONYMOUS_ARRAY_INITIALIZER (node));
12159       if (node == error_mark_node)
12160         return error_mark_node;
12161       CAN_COMPLETE_NORMALLY (node) = 1;
12162       return node;
12163
12164     case NEW_CLASS_EXPR:
12165     case CALL_EXPR:
12166       /* Complete function's argument(s) first */
12167       if (complete_function_arguments (node))
12168         return error_mark_node;
12169       else
12170         {
12171           tree decl, wfl = TREE_OPERAND (node, 0);
12172           int in_this = CALL_THIS_CONSTRUCTOR_P (node);
12173           int from_super = (EXPR_WFL_NODE (TREE_OPERAND (node, 0)) ==
12174                            super_identifier_node);
12175           tree arguments;
12176 #ifdef USE_MAPPED_LOCATION
12177           source_location location = EXPR_LOCATION (node);
12178 #else
12179           int location = EXPR_WFL_LINECOL (node);
12180 #endif
12181
12182           node = patch_method_invocation (node, NULL_TREE, NULL_TREE,
12183                                           from_super, 0, &decl);
12184           if (node == error_mark_node)
12185             return error_mark_node;
12186
12187           if (TREE_CODE (node) == CALL_EXPR
12188               && TREE_OPERAND (node, 1) != NULL_TREE)
12189             arguments = TREE_VALUE (TREE_OPERAND (node, 1));
12190           else
12191             arguments = NULL_TREE;
12192           check_thrown_exceptions (location, decl, arguments);
12193           /* If we call this(...), register signature and positions */
12194           if (in_this)
12195             DECL_CONSTRUCTOR_CALLS (current_function_decl) =
12196               tree_cons (wfl, decl,
12197                          DECL_CONSTRUCTOR_CALLS (current_function_decl));
12198           CAN_COMPLETE_NORMALLY (node) = 1;
12199           return force_evaluation_order (node);
12200         }
12201
12202     case MODIFY_EXPR:
12203       /* Save potential wfls */
12204       wfl_op1 = TREE_OPERAND (node, 0);
12205       TREE_OPERAND (node, 0) = nn = java_complete_lhs (wfl_op1);
12206
12207       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node)
12208           && TREE_CODE (nn) == VAR_DECL && TREE_STATIC (nn)
12209           && DECL_INITIAL (nn) != NULL_TREE)
12210         {
12211           tree value;
12212
12213           value = fold_constant_for_init (nn, nn);
12214
12215           /* When we have a primitype type, or a string and we're not
12216              emitting a class file, we actually don't want to generate
12217              anything for the assignment. */
12218           if (value != NULL_TREE &&
12219               (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) ||
12220                (TREE_TYPE (value) == string_ptr_type_node &&
12221                 ! flag_emit_class_files)))
12222             {
12223               /* Prepare node for patch_assignment */
12224               TREE_OPERAND (node, 1) = value;
12225               /* Call patch assignment to verify the assignment */
12226               if (patch_assignment (node, wfl_op1) == error_mark_node)
12227                 return error_mark_node;
12228               /* Set DECL_INITIAL properly (a conversion might have
12229                  been decided by patch_assignment) and return the
12230                  empty statement. */
12231               else
12232                 {
12233                   tree patched = patch_string (TREE_OPERAND (node, 1));
12234                   if (patched)
12235                     DECL_INITIAL (nn) = patched;
12236                   else
12237                     DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12238                   DECL_FIELD_FINAL_IUD (nn) = 1;
12239                   return build_java_empty_stmt ();
12240                 }
12241             }
12242           if (! flag_emit_class_files)
12243             DECL_INITIAL (nn) = NULL_TREE;
12244         }
12245       wfl_op2 = TREE_OPERAND (node, 1);
12246
12247       if (TREE_OPERAND (node, 0) == error_mark_node)
12248         return error_mark_node;
12249
12250       flag = COMPOUND_ASSIGN_P (wfl_op2);
12251       if (flag)
12252         {
12253           /* This might break when accessing outer field from inner
12254              class. TESTME, FIXME */
12255           tree lvalue = java_stabilize_reference (TREE_OPERAND (node, 0));
12256
12257           /* Hand stabilize the lhs on both places */
12258           TREE_OPERAND (node, 0) = lvalue;
12259           TREE_OPERAND (TREE_OPERAND (node, 1), 0) =
12260             (flag_emit_class_files ? lvalue : save_expr (lvalue));
12261
12262           /* 15.25.2.a: Left hand is not an array access. FIXME */
12263           /* Now complete the RHS. We write it back later on. */
12264           nn = java_complete_tree (TREE_OPERAND (node, 1));
12265
12266           if ((cn = patch_string (nn)))
12267             nn = cn;
12268
12269           /* The last part of the rewrite for E1 op= E2 is to have
12270              E1 = (T)(E1 op E2), with T being the type of E1. */
12271           nn = java_complete_tree (build_cast (EXPR_WFL_LINECOL (wfl_op2),
12272                                                TREE_TYPE (lvalue), nn));
12273
12274           /* If the assignment is compound and has reference type,
12275              then ensure the LHS has type String and nothing else.  */
12276           if (JREFERENCE_TYPE_P (TREE_TYPE (lvalue))
12277               && ! JSTRING_TYPE_P (TREE_TYPE (lvalue)))
12278             parse_error_context (wfl_op2,
12279                                  "Incompatible type for %<+=%>. Can't convert %qs to %<java.lang.String%>",
12280                                  lang_printable_name (TREE_TYPE (lvalue), 0));
12281
12282           /* 15.25.2.b: Left hand is an array access. FIXME */
12283         }
12284
12285       /* If we're about to patch a NEW_ARRAY_INIT, we call a special
12286          function to complete this RHS. Note that a NEW_ARRAY_INIT
12287          might have been already fully expanded if created as a result
12288          of processing an anonymous array initializer. We avoid doing
12289          the operation twice by testing whether the node already bears
12290          a type. */
12291       else if (TREE_CODE (wfl_op2) == NEW_ARRAY_INIT && !TREE_TYPE (wfl_op2))
12292         nn = patch_new_array_init (TREE_TYPE (TREE_OPERAND (node, 0)),
12293                                    TREE_OPERAND (node, 1));
12294       /* Otherwise we simply complete the RHS */
12295       else
12296         nn = java_complete_tree (TREE_OPERAND (node, 1));
12297
12298       if (nn == error_mark_node)
12299         return error_mark_node;
12300
12301       /* Write back the RHS as we evaluated it. */
12302       TREE_OPERAND (node, 1) = nn;
12303
12304       /* In case we're handling = with a String as a RHS, we need to
12305          produce a String out of the RHS (it might still be a
12306          STRING_CST or a StringBuffer at this stage */
12307       if ((nn = patch_string (TREE_OPERAND (node, 1))))
12308         TREE_OPERAND (node, 1) = nn;
12309
12310       if ((nn = nested_field_access_fix (wfl_op1, TREE_OPERAND (node, 0),
12311                                          TREE_OPERAND (node, 1))))
12312         {
12313           /* We return error_mark_node if nested_field_access_fix
12314              detects we write into a final. */
12315           if (nn == error_mark_node)
12316             return error_mark_node;
12317           node = nn;
12318         }
12319       else
12320         {
12321           node = patch_assignment (node, wfl_op1);
12322           if (node == error_mark_node)
12323             return error_mark_node;
12324           /* Reorganize the tree if necessary. */
12325           if (flag && (!JREFERENCE_TYPE_P (TREE_TYPE (node))
12326                        || JSTRING_P (TREE_TYPE (node))))
12327             node = java_refold (node);
12328         }
12329
12330       /* Seek to set DECL_INITIAL to a proper value, since it might have
12331          undergone a conversion in patch_assignment. We do that only when
12332          it's necessary to have DECL_INITIAL properly set. */
12333       nn = TREE_OPERAND (node, 0);
12334       if (TREE_CODE (nn) == VAR_DECL
12335           && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
12336           && FIELD_STATIC (nn) && FIELD_FINAL (nn)
12337           && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
12338               || TREE_TYPE (nn) == string_ptr_type_node))
12339         DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
12340
12341       CAN_COMPLETE_NORMALLY (node) = 1;
12342       return node;
12343
12344     case MULT_EXPR:
12345     case PLUS_EXPR:
12346     case MINUS_EXPR:
12347     case LSHIFT_EXPR:
12348     case RSHIFT_EXPR:
12349     case URSHIFT_EXPR:
12350     case BIT_AND_EXPR:
12351     case BIT_XOR_EXPR:
12352     case BIT_IOR_EXPR:
12353     case TRUNC_MOD_EXPR:
12354     case TRUNC_DIV_EXPR:
12355     case RDIV_EXPR:
12356     case TRUTH_ANDIF_EXPR:
12357     case TRUTH_ORIF_EXPR:
12358     case EQ_EXPR:
12359     case NE_EXPR:
12360     case GT_EXPR:
12361     case GE_EXPR:
12362     case LT_EXPR:
12363     case LE_EXPR:
12364       /* Operands 0 and 1 are WFL in certain cases only. patch_binop
12365          knows how to handle those cases. */
12366       wfl_op1 = TREE_OPERAND (node, 0);
12367       wfl_op2 = TREE_OPERAND (node, 1);
12368
12369       CAN_COMPLETE_NORMALLY (node) = 1;
12370       /* Don't complete string nodes if dealing with the PLUS operand. */
12371       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op1))
12372         {
12373           nn = java_complete_tree (wfl_op1);
12374           if (nn == error_mark_node)
12375             return error_mark_node;
12376
12377           TREE_OPERAND (node, 0) = nn;
12378         }
12379       if (TREE_CODE (node) != PLUS_EXPR || !JSTRING_P (wfl_op2))
12380         {
12381           nn = java_complete_tree (wfl_op2);
12382           if (nn == error_mark_node)
12383             return error_mark_node;
12384
12385           TREE_OPERAND (node, 1) = nn;
12386         }
12387       return patch_binop (node, wfl_op1, wfl_op2, 0);
12388
12389     case INSTANCEOF_EXPR:
12390       wfl_op1 = TREE_OPERAND (node, 0);
12391       COMPLETE_CHECK_OP_0 (node);
12392       return patch_binop (node, wfl_op1, TREE_OPERAND (node, 1), 0);
12393
12394     case UNARY_PLUS_EXPR:
12395     case NEGATE_EXPR:
12396     case TRUTH_NOT_EXPR:
12397     case BIT_NOT_EXPR:
12398     case PREDECREMENT_EXPR:
12399     case PREINCREMENT_EXPR:
12400     case POSTDECREMENT_EXPR:
12401     case POSTINCREMENT_EXPR:
12402     case CONVERT_EXPR:
12403       /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
12404          how to handle those cases. */
12405       wfl_op1 = TREE_OPERAND (node, 0);
12406       CAN_COMPLETE_NORMALLY (node) = 1;
12407       if (TREE_CODE (node) == PREDECREMENT_EXPR
12408           || TREE_CODE (node) == PREINCREMENT_EXPR
12409           || TREE_CODE (node) == POSTDECREMENT_EXPR
12410           || TREE_CODE (node) == POSTINCREMENT_EXPR)
12411         { /* We don't want static finals to be resolved to their value
12412              to avoid ICEing later. It solves PR8923. */
12413           TREE_OPERAND (node, 0) = java_complete_lhs (wfl_op1);
12414         }
12415       else
12416         {
12417           TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12418         }
12419       if (TREE_OPERAND (node, 0) == error_mark_node)
12420         return error_mark_node;
12421       node = patch_unaryop (node, wfl_op1);
12422       CAN_COMPLETE_NORMALLY (node) = 1;
12423       break;
12424
12425     case ARRAY_REF:
12426       /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
12427          how to handle those cases. */
12428       wfl_op1 = TREE_OPERAND (node, 0);
12429       TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
12430       if (TREE_OPERAND (node, 0) == error_mark_node)
12431         return error_mark_node;
12432       if (!flag_emit_class_files)
12433         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
12434       /* The same applies to wfl_op2 */
12435       wfl_op2 = TREE_OPERAND (node, 1);
12436       TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
12437       if (TREE_OPERAND (node, 1) == error_mark_node)
12438         return error_mark_node;
12439       if (!flag_emit_class_files)
12440         TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
12441       return patch_array_ref (node);
12442
12443     case RECORD_TYPE:
12444       return node;;
12445
12446     case COMPONENT_REF:
12447       /* The first step in the re-write of qualified name handling.  FIXME.
12448          So far, this is only to support PRIMTYPE.class ->
12449          PRIMCLASS.TYPE. */
12450       {
12451         tree prim_class = TREE_OPERAND (node, 0);
12452         tree name = TREE_OPERAND (node, 1);
12453         tree field;
12454
12455         gcc_assert (TREE_CODE (prim_class) == NOP_EXPR);
12456         prim_class = java_complete_tree (TREE_TYPE (prim_class));
12457         gcc_assert (TREE_CODE (prim_class) == RECORD_TYPE);
12458         field = lookup_field_wrapper (prim_class, name);
12459
12460         if (field == NULL_TREE)
12461           {
12462             error ("missing static field %qs", IDENTIFIER_POINTER (name));
12463             return error_mark_node;
12464           }
12465         if (! FIELD_STATIC (field))
12466           {
12467             error ("not a static field %qs", IDENTIFIER_POINTER (name));
12468             return error_mark_node;
12469           }
12470         return field;
12471       }
12472       break;
12473
12474     case THIS_EXPR:
12475       /* Can't use THIS in a static environment */
12476       if (!current_this)
12477         {
12478           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12479           parse_error_context (wfl_operator,
12480                                "Keyword %<this%> used outside allowed context");
12481           TREE_TYPE (node) = error_mark_node;
12482           return error_mark_node;
12483         }
12484       if (ctxp->explicit_constructor_p)
12485         {
12486           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12487           parse_error_context
12488             (wfl_operator, "Can't reference %<this%> or %<super%> before the superclass constructor has been called");
12489           TREE_TYPE (node) = error_mark_node;
12490           return error_mark_node;
12491         }
12492       return current_this;
12493
12494     case CLASS_LITERAL:
12495       CAN_COMPLETE_NORMALLY (node) = 1;
12496       node = patch_incomplete_class_ref (node);
12497       if (node == error_mark_node)
12498         return error_mark_node;
12499       break;
12500
12501     default:
12502       CAN_COMPLETE_NORMALLY (node) = 1;
12503       /* Ok: may be we have a STRING_CST or a crafted `StringBuffer'
12504          and it's time to turn it into the appropriate String object */
12505       if ((nn = patch_string (node)))
12506         node = nn;
12507       else
12508         internal_error ("No case for %s", tree_code_name [TREE_CODE (node)]);
12509     }
12510   return node;
12511 }
12512
12513 /* Complete function call's argument. Return a nonzero value is an
12514    error was found.  */
12515
12516 static int
12517 complete_function_arguments (tree node)
12518 {
12519   int flag = 0;
12520   tree cn;
12521
12522   ctxp->explicit_constructor_p += (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12523   for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
12524     {
12525       tree wfl = TREE_VALUE (cn), parm, temp;
12526       parm = java_complete_tree (wfl);
12527
12528       if (parm == error_mark_node)
12529         {
12530           flag = 1;
12531           continue;
12532         }
12533       /* If we have a string literal that we haven't transformed yet or a
12534          crafted string buffer, as a result of the use of the String
12535          `+' operator. Build `parm.toString()' and expand it. */
12536       if ((temp = patch_string (parm)))
12537         parm = temp;
12538
12539       TREE_VALUE (cn) = parm;
12540     }
12541   ctxp->explicit_constructor_p -= (CALL_EXPLICIT_CONSTRUCTOR_P (node) ? 1 : 0);
12542   return flag;
12543 }
12544
12545 /* Sometimes (for loops and variable initialized during their
12546    declaration), we want to wrap a statement around a WFL and turn it
12547    debugable.  */
12548
12549 static tree
12550 build_debugable_stmt (int location, tree stmt)
12551 {
12552   if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
12553     {
12554 #ifdef USE_MAPPED_LOCATION
12555       stmt = expr_add_location (stmt, location, 1);
12556 #else
12557       stmt = build_expr_wfl (stmt, input_filename, 0, 0);
12558       EXPR_WFL_LINECOL (stmt) = location;
12559       JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
12560 #endif
12561     }
12562   return stmt;
12563 }
12564
12565 static tree
12566 build_expr_block (tree body, tree decls)
12567 {
12568   tree node = make_node (BLOCK);
12569   BLOCK_EXPR_DECLS (node) = decls;
12570   BLOCK_EXPR_BODY (node) = body;
12571   if (body)
12572     TREE_TYPE (node) = TREE_TYPE (body);
12573   TREE_SIDE_EFFECTS (node) = 1;
12574   return node;
12575 }
12576
12577 /* Create a new function block and link it appropriately to current
12578    function block chain */
12579
12580 static tree
12581 enter_block (void)
12582 {
12583   tree b = build_expr_block (NULL_TREE, NULL_TREE);
12584
12585   /* Link block B supercontext to the previous block. The current
12586      function DECL is used as supercontext when enter_a_block is called
12587      for the first time for a given function. The current function body
12588      (DECL_FUNCTION_BODY) is set to be block B.  */
12589
12590   tree fndecl = current_function_decl;
12591
12592   if (!fndecl) {
12593     BLOCK_SUPERCONTEXT (b) = current_static_block;
12594     current_static_block = b;
12595   }
12596
12597   else if (!DECL_FUNCTION_BODY (fndecl))
12598     {
12599       BLOCK_SUPERCONTEXT (b) = fndecl;
12600       DECL_FUNCTION_BODY (fndecl) = b;
12601     }
12602   else
12603     {
12604       BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
12605       DECL_FUNCTION_BODY (fndecl) = b;
12606     }
12607   return b;
12608 }
12609
12610 /* Exit a block by changing the current function body
12611    (DECL_FUNCTION_BODY) to the current block super context, only if
12612    the block being exited isn't the method's top level one.  */
12613
12614 static tree
12615 exit_block (void)
12616 {
12617   tree b;
12618   if (current_function_decl)
12619     {
12620       b = DECL_FUNCTION_BODY (current_function_decl);
12621       if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
12622         DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
12623     }
12624   else
12625     {
12626       b = current_static_block;
12627
12628       if (BLOCK_SUPERCONTEXT (b))
12629         current_static_block = BLOCK_SUPERCONTEXT (b);
12630     }
12631   return b;
12632 }
12633
12634 /* Lookup for NAME in the nested function's blocks, all the way up to
12635    the current toplevel one. It complies with Java's local variable
12636    scoping rules.  */
12637
12638 static tree
12639 lookup_name_in_blocks (tree name)
12640 {
12641   tree b = GET_CURRENT_BLOCK (current_function_decl);
12642
12643   while (b != current_function_decl)
12644     {
12645       tree current;
12646
12647       /* Paranoid sanity check. To be removed */
12648       if (TREE_CODE (b) != BLOCK)
12649         abort ();
12650
12651       for (current = BLOCK_EXPR_DECLS (b); current;
12652            current = TREE_CHAIN (current))
12653         if (DECL_NAME (current) == name)
12654           return current;
12655       b = BLOCK_SUPERCONTEXT (b);
12656     }
12657   return NULL_TREE;
12658 }
12659
12660 static void
12661 maybe_absorb_scoping_blocks (void)
12662 {
12663   while (BLOCK_IS_IMPLICIT (GET_CURRENT_BLOCK (current_function_decl)))
12664     {
12665       tree b = exit_block ();
12666       java_method_add_stmt (current_function_decl, b);
12667       SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", input_line));
12668     }
12669 }
12670
12671 \f
12672 /* This section of the source is reserved to build_* functions that
12673    are building incomplete tree nodes and the patch_* functions that
12674    are completing them.  */
12675
12676 /* Wrap a non WFL node around a WFL.  */
12677
12678 static tree
12679 build_wfl_wrap (tree node, int location)
12680 {
12681   tree wfl, node_to_insert = node;
12682
12683   /* We want to process THIS . xxx symbolically, to keep it consistent
12684      with the way we're processing SUPER. A THIS from a primary as a
12685      different form than a SUPER. Turn THIS into something symbolic */
12686   if (TREE_CODE (node) == THIS_EXPR)
12687     node_to_insert = wfl = build_wfl_node (this_identifier_node);
12688   else
12689 #ifdef USE_MAPPED_LOCATION
12690     wfl = build_unknown_wfl (NULL_TREE);
12691
12692   SET_EXPR_LOCATION (wfl, location);
12693 #else
12694     wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
12695
12696   EXPR_WFL_LINECOL (wfl) = location;
12697 #endif
12698   EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (node_to_insert, NULL_TREE);
12699   return wfl;
12700 }
12701
12702 /* Build a super() constructor invocation. Returns an empty statement if
12703    we're currently dealing with the class java.lang.Object. */
12704
12705 static tree
12706 build_super_invocation (tree mdecl)
12707 {
12708   if (DECL_CONTEXT (mdecl) == object_type_node)
12709     return build_java_empty_stmt ();
12710   else
12711     {
12712       tree super_wfl = build_wfl_node (super_identifier_node);
12713       tree a = NULL_TREE, t;
12714
12715       /* This is called after parsing is done, so the parser context
12716          won't be accurate. Set location info from current_class decl. */
12717       tree class_wfl = lookup_cl (TYPE_NAME (current_class));
12718       EXPR_WFL_LINECOL (super_wfl) = EXPR_WFL_LINECOL (class_wfl);
12719
12720       /* If we're dealing with an anonymous class, pass the arguments
12721          of the crafted constructor along. */
12722       if (ANONYMOUS_CLASS_P (DECL_CONTEXT (mdecl)))
12723         {
12724           SKIP_THIS_AND_ARTIFICIAL_PARMS (t, mdecl);
12725           for (; t != end_params_node; t = TREE_CHAIN (t))
12726             a = tree_cons (NULL_TREE, build_wfl_node (TREE_PURPOSE (t)), a);
12727         }
12728       return build_method_invocation (super_wfl, a);
12729     }
12730 }
12731
12732 /* Build a SUPER/THIS qualified method invocation.  */
12733
12734 static tree
12735 build_this_super_qualified_invocation (int use_this, tree name, tree args,
12736                                        int lloc, int rloc)
12737 {
12738   tree invok;
12739   tree wfl =
12740     build_wfl_node (use_this ? this_identifier_node : super_identifier_node);
12741   EXPR_WFL_LINECOL (wfl) = lloc;
12742   invok = build_method_invocation (name, args);
12743   return make_qualified_primary (wfl, invok, rloc);
12744 }
12745
12746 /* Build an incomplete CALL_EXPR node. */
12747
12748 static tree
12749 build_method_invocation (tree name, tree args)
12750 {
12751   tree call = build3 (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
12752   TREE_SIDE_EFFECTS (call) = 1;
12753   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12754   return call;
12755 }
12756
12757 /* Build an incomplete new xxx(...) node. */
12758
12759 static tree
12760 build_new_invocation (tree name, tree args)
12761 {
12762   tree call = build3 (NEW_CLASS_EXPR, NULL_TREE, name, args, NULL_TREE);
12763   TREE_SIDE_EFFECTS (call) = 1;
12764   EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
12765   return call;
12766 }
12767
12768 /* Build an incomplete assignment expression. */
12769
12770 static tree
12771 build_assignment (int op, int op_location, tree lhs, tree rhs)
12772 {
12773   tree assignment;
12774   /* Build the corresponding binop if we deal with a Compound
12775      Assignment operator. Mark the binop sub-tree as part of a
12776      Compound Assignment expression */
12777   if (op != ASSIGN_TK)
12778     {
12779       rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
12780       COMPOUND_ASSIGN_P (rhs) = 1;
12781     }
12782   assignment = build2 (MODIFY_EXPR, NULL_TREE, lhs, rhs);
12783   TREE_SIDE_EFFECTS (assignment) = 1;
12784   EXPR_WFL_LINECOL (assignment) = op_location;
12785   return assignment;
12786 }
12787
12788 /* Print an INTEGER_CST node as decimal in a static buffer, and return
12789    the buffer.  This is used only for string conversion.  */
12790 static char *
12791 string_convert_int_cst (tree node)
12792 {
12793   /* Long.MIN_VALUE is -9223372036854775808, 20 characters.  */
12794   static char buffer[21];
12795
12796   unsigned HOST_WIDE_INT lo = TREE_INT_CST_LOW (node);
12797   unsigned HOST_WIDE_INT hi = TREE_INT_CST_HIGH (node);
12798   char *p = buffer + sizeof (buffer);
12799   int neg = 0;
12800
12801   unsigned HOST_WIDE_INT hibit = (((unsigned HOST_WIDE_INT) 1)
12802                                   << (HOST_BITS_PER_WIDE_INT - 1));
12803
12804   *--p = '\0';
12805
12806   /* If negative, note the fact and negate the value.  */
12807   if ((hi & hibit))
12808     {
12809       lo = ~lo;
12810       hi = ~hi;
12811       if (++lo == 0)
12812         ++hi;
12813       neg = 1;
12814     }
12815
12816   /* Divide by 10 until there are no bits left.  */
12817   do
12818     {
12819       unsigned HOST_WIDE_INT acc = 0;
12820       unsigned HOST_WIDE_INT outhi = 0, outlo = 0;
12821       unsigned int i;
12822
12823       /* Use long division to compute the result and the remainder.  */
12824       for (i = 0; i < 2 * HOST_BITS_PER_WIDE_INT; ++i)
12825         {
12826           /* Shift a bit into accumulator.  */
12827           acc <<= 1;
12828           if ((hi & hibit))
12829             acc |= 1;
12830
12831           /* Shift the value.  */
12832           hi <<= 1;
12833           if ((lo & hibit))
12834             hi |= 1;
12835           lo <<= 1;
12836
12837           /* Shift the correct bit into the result.  */
12838           outhi <<= 1;
12839           if ((outlo & hibit))
12840             outhi |= 1;
12841           outlo <<= 1;
12842           if (acc >= 10)
12843             {
12844               acc -= 10;
12845               outlo |= 1;
12846             }
12847         }
12848
12849       /* '0' == 060 in Java, but might not be here (think EBCDIC).  */
12850       *--p = '\060' + acc;
12851
12852       hi = outhi;
12853       lo = outlo;
12854     }
12855   while (hi || lo);
12856
12857   if (neg)
12858     *--p = '\055'; /* '-' == 055 in Java, but might not be here.  */
12859
12860   return p;
12861 }
12862
12863 /* Print an INTEGER_CST node in a static buffer, and return the
12864    buffer.  This is used only for error handling.  */
12865 char *
12866 print_int_node (tree node)
12867 {
12868   static char buffer [80];
12869   if (TREE_CONSTANT_OVERFLOW (node))
12870     sprintf (buffer, "<overflow>");
12871
12872   if (TREE_INT_CST_HIGH (node) == 0)
12873     sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
12874              TREE_INT_CST_LOW (node));
12875   else if (TREE_INT_CST_HIGH (node) == -1
12876            && TREE_INT_CST_LOW (node) != 0)
12877     sprintf (buffer, "-" HOST_WIDE_INT_PRINT_UNSIGNED,
12878              -TREE_INT_CST_LOW (node));
12879   else
12880     sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
12881              TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
12882
12883   return buffer;
12884 }
12885
12886 \f
12887 /* Return 1 if an assignment to a FINAL is attempted in a non suitable
12888    context.  */
12889
12890 /* 15.25 Assignment operators. */
12891
12892 static tree
12893 patch_assignment (tree node, tree wfl_op1)
12894 {
12895   tree rhs = TREE_OPERAND (node, 1);
12896   tree lvalue = TREE_OPERAND (node, 0), llvalue;
12897   tree lhs_type = NULL_TREE, rhs_type, new_rhs = NULL_TREE;
12898   int error_found = 0;
12899   int lvalue_from_array = 0;
12900   int is_return = 0;
12901
12902   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
12903
12904   /* Lhs can be a named variable */
12905   if (JDECL_P (lvalue))
12906     {
12907       lhs_type = TREE_TYPE (lvalue);
12908     }
12909   /* Or Lhs can be an array access. */
12910   else if (TREE_CODE (lvalue) == ARRAY_REF)
12911     {
12912       lhs_type = TREE_TYPE (lvalue);
12913       lvalue_from_array = 1;
12914     }
12915   /* Or a field access */
12916   else if (TREE_CODE (lvalue) == COMPONENT_REF)
12917     lhs_type = TREE_TYPE (lvalue);
12918   /* Or a function return slot */
12919   else if (TREE_CODE (lvalue) == RESULT_DECL)
12920     {
12921       /* If the return type is an integral type, then we create the
12922          RESULT_DECL with a promoted type, but we need to do these
12923          checks against the unpromoted type to ensure type safety.  So
12924          here we look at the real type, not the type of the decl we
12925          are modifying.  */
12926       lhs_type = TREE_TYPE (TREE_TYPE (current_function_decl));
12927       is_return = 1;
12928     }
12929   /* Otherwise, we might want to try to write into an optimized static
12930      final, this is an of a different nature, reported further on. */
12931   else if (TREE_CODE (wfl_op1) == EXPR_WITH_FILE_LOCATION
12932            && resolve_expression_name (wfl_op1, &llvalue))
12933     {
12934       lhs_type = TREE_TYPE (lvalue);
12935     }
12936   else
12937     {
12938       parse_error_context (wfl_op1, "Invalid left hand side of assignment");
12939       error_found = 1;
12940     }
12941
12942   rhs_type = TREE_TYPE (rhs);
12943
12944   /* 5.1 Try the assignment conversion for builtin type. */
12945   new_rhs = try_builtin_assignconv (wfl_op1, lhs_type, rhs);
12946
12947   /* 5.2 If it failed, try a reference conversion */
12948   if (!new_rhs)
12949     new_rhs = try_reference_assignconv (lhs_type, rhs);
12950
12951   /* 15.25.2 If we have a compound assignment, convert RHS into the
12952      type of the LHS */
12953   else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12954     new_rhs = convert (lhs_type, rhs);
12955
12956   /* Explicit cast required. This is an error */
12957   if (!new_rhs)
12958     {
12959       char *t1 = xstrdup (lang_printable_name (TREE_TYPE (rhs), 0));
12960       char *t2 = xstrdup (lang_printable_name (lhs_type, 0));
12961       tree wfl;
12962       char operation [32];      /* Max size known */
12963
12964       /* If the assignment is part of a declaration, we use the WFL of
12965          the declared variable to point out the error and call it a
12966          declaration problem. If the assignment is a genuine =
12967          operator, we call is a operator `=' problem, otherwise we
12968          call it an assignment problem. In both of these last cases,
12969          we use the WFL of the operator to indicate the error. */
12970
12971       if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
12972         {
12973           wfl = wfl_op1;
12974           strcpy (operation, "declaration");
12975         }
12976       else
12977         {
12978           wfl = wfl_operator;
12979           if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
12980             strcpy (operation, "assignment");
12981           else if (is_return)
12982             strcpy (operation, "'return'");
12983           else
12984             strcpy (operation, "'='");
12985         }
12986
12987       if (!valid_cast_to_p (rhs_type, lhs_type))
12988         parse_error_context
12989           (wfl, "Incompatible type for %s. Can't convert %qs to %qs",
12990            operation, t1, t2);
12991       else
12992         parse_error_context (wfl, "Incompatible type for %s. Explicit cast needed to convert %qs to %qs",
12993                              operation, t1, t2);
12994       free (t1); free (t2);
12995       error_found = 1;
12996     }
12997
12998   if (error_found)
12999     return error_mark_node;
13000
13001   /* If we're processing a `return' statement, promote the actual type
13002      to the promoted type.  */
13003   if (is_return)
13004     new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
13005
13006   /* 10.10: Array Store Exception runtime check */
13007   if (!flag_emit_class_files
13008       && lvalue_from_array
13009       && JREFERENCE_TYPE_P (TYPE_ARRAY_ELEMENT (lhs_type)))
13010     {
13011       tree array, store_check, base, index_expr;
13012
13013       /* Save RHS so that it doesn't get re-evaluated by the store check. */
13014       new_rhs = save_expr (new_rhs);
13015
13016       /* Get the INDIRECT_REF. */
13017       array = TREE_OPERAND (TREE_OPERAND (lvalue, 0), 0);
13018       /* Get the array pointer expr. */
13019       array = TREE_OPERAND (array, 0);
13020       store_check = build_java_arraystore_check (array, new_rhs);
13021
13022       index_expr = TREE_OPERAND (lvalue, 1);
13023
13024       if (TREE_CODE (index_expr) == COMPOUND_EXPR)
13025         {
13026           /* A COMPOUND_EXPR here is a bounds check. The bounds check must
13027              happen before the store check, so prepare to insert the store
13028              check within the second operand of the existing COMPOUND_EXPR. */
13029           base = index_expr;
13030         }
13031       else
13032         base = lvalue;
13033
13034       index_expr = TREE_OPERAND (base, 1);
13035       TREE_OPERAND (base, 1) = build2 (COMPOUND_EXPR, TREE_TYPE (index_expr),
13036                                        store_check, index_expr);
13037     }
13038
13039   /* Final locals can be used as case values in switch
13040      statement. Prepare them for this eventuality. */
13041   if (TREE_CODE (lvalue) == VAR_DECL
13042       && DECL_FINAL (lvalue)
13043       && TREE_CONSTANT (new_rhs)
13044       && IDENTIFIER_LOCAL_VALUE (DECL_NAME (lvalue))
13045       && JINTEGRAL_TYPE_P (TREE_TYPE (lvalue))
13046       )
13047     {
13048       TREE_CONSTANT (lvalue) = 1;
13049       TREE_INVARIANT (lvalue) = 1;
13050       DECL_INITIAL (lvalue) = new_rhs;
13051     }
13052
13053   /* Copy the rhs if it's a reference.  */
13054   if (! flag_check_references && ! flag_emit_class_files && optimize > 0)
13055     {
13056       switch (TREE_CODE (new_rhs))
13057         {
13058         case ARRAY_REF:
13059         case INDIRECT_REF:
13060         case COMPONENT_REF:
13061           /* Transform a = foo.bar
13062              into a = ({int tmp; tmp = foo.bar;}).
13063              We need to ensure that if a read from memory fails
13064              because of a NullPointerException, a destination variable
13065              will remain unchanged.  An explicit temporary does what
13066              we need.
13067
13068              If flag_check_references is set, this is unnecessary
13069              because we'll check each reference before doing any
13070              reads.  If optimize is not set the result will never be
13071              written to a stack slot that contains the LHS.  */
13072           {
13073             tree tmp = build_decl (VAR_DECL, get_identifier ("<tmp>"),
13074                                    TREE_TYPE (new_rhs));
13075             tree block = make_node (BLOCK);
13076             tree assignment
13077               = build2 (MODIFY_EXPR, TREE_TYPE (new_rhs), tmp, fold (new_rhs));
13078             DECL_CONTEXT (tmp) = current_function_decl;
13079             TREE_TYPE (block) = TREE_TYPE (new_rhs);
13080             BLOCK_VARS (block) = tmp;
13081             BLOCK_EXPR_BODY (block) = assignment;
13082             TREE_SIDE_EFFECTS (block) = 1;
13083             new_rhs = block;
13084           }
13085           break;
13086         default:
13087           break;
13088         }
13089     }
13090
13091   TREE_OPERAND (node, 0) = lvalue;
13092   TREE_OPERAND (node, 1) = new_rhs;
13093   TREE_TYPE (node) = lhs_type;
13094   return node;
13095 }
13096
13097 /* Check that type SOURCE can be cast into type DEST. If the cast
13098    can't occur at all, return NULL; otherwise, return a possibly
13099    modified rhs.  */
13100
13101 static tree
13102 try_reference_assignconv (tree lhs_type, tree rhs)
13103 {
13104   tree new_rhs = NULL_TREE;
13105   tree rhs_type = TREE_TYPE (rhs);
13106
13107   if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
13108     {
13109       /* `null' may be assigned to any reference type */
13110       if (rhs == null_pointer_node)
13111         new_rhs = null_pointer_node;
13112       /* Try the reference assignment conversion */
13113       else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
13114         new_rhs = rhs;
13115       /* This is a magic assignment that we process differently */
13116       else if (TREE_CODE (rhs) == JAVA_EXC_OBJ_EXPR)
13117         new_rhs = rhs;
13118     }
13119   return new_rhs;
13120 }
13121
13122 /* Check that RHS can be converted into LHS_TYPE by the assignment
13123    conversion (5.2), for the cases of RHS being a builtin type. Return
13124    NULL_TREE if the conversion fails or if because RHS isn't of a
13125    builtin type. Return a converted RHS if the conversion is possible.  */
13126
13127 static tree
13128 try_builtin_assignconv (tree wfl_op1, tree lhs_type, tree rhs)
13129 {
13130   tree new_rhs = NULL_TREE;
13131   tree rhs_type = TREE_TYPE (rhs);
13132
13133   /* Handle boolean specially.  */
13134   if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
13135       || TREE_CODE (lhs_type) == BOOLEAN_TYPE)
13136     {
13137       if (TREE_CODE (rhs_type) == BOOLEAN_TYPE
13138           && TREE_CODE (lhs_type) == BOOLEAN_TYPE)
13139         new_rhs = rhs;
13140     }
13141
13142   /* 5.1.1 Try Identity Conversion,
13143      5.1.2 Try Widening Primitive Conversion */
13144   else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
13145     new_rhs = convert (lhs_type, rhs);
13146
13147   /* Try a narrowing primitive conversion (5.1.3):
13148        - expression is a constant expression of type byte, short, char,
13149          or int, AND
13150        - variable is byte, short or char AND
13151        - The value of the expression is representable in the type of the
13152          variable */
13153   else if ((rhs_type == byte_type_node || rhs_type == short_type_node
13154             || rhs_type == char_type_node || rhs_type == int_type_node)
13155             && TREE_CONSTANT (rhs)
13156            && (lhs_type == byte_type_node || lhs_type == char_type_node
13157                || lhs_type == short_type_node))
13158     {
13159       if (int_fits_type_p (rhs, lhs_type))
13160         new_rhs = convert (lhs_type, rhs);
13161       else if (wfl_op1)         /* Might be called with a NULL */
13162         parse_warning_context
13163           (wfl_op1,
13164            "Constant expression %qs too wide for narrowing primitive conversion to %qs",
13165            print_int_node (rhs), lang_printable_name (lhs_type, 0));
13166       /* Reported a warning that will turn into an error further
13167          down, so we don't return */
13168     }
13169
13170   return new_rhs;
13171 }
13172
13173 /* Return 1 if RHS_TYPE can be converted to LHS_TYPE by identity
13174    conversion (5.1.1) or widening primitive conversion (5.1.2).  Return
13175    0 is the conversion test fails.  This implements parts the method
13176    invocation conversion (5.3).  */
13177
13178 static int
13179 valid_builtin_assignconv_identity_widening_p (tree lhs_type, tree rhs_type)
13180 {
13181   /* 5.1.1: This is the identity conversion part. */
13182   if (lhs_type == rhs_type)
13183     return 1;
13184
13185   /* Reject non primitive types and boolean conversions.  */
13186   if (!JNUMERIC_TYPE_P (lhs_type) || !JNUMERIC_TYPE_P (rhs_type))
13187     return 0;
13188
13189   /* 5.1.2: widening primitive conversion. byte, even if it's smaller
13190      than a char can't be converted into a char. Short can't too, but
13191      the < test below takes care of that */
13192   if (lhs_type == char_type_node && rhs_type == byte_type_node)
13193     return 0;
13194
13195   /* Accept all promoted type here. Note, we can't use <= in the test
13196      below, because we still need to bounce out assignments of short
13197      to char and the likes */
13198   if (lhs_type == int_type_node
13199       && (rhs_type == promoted_byte_type_node
13200           || rhs_type == promoted_short_type_node
13201           || rhs_type == promoted_char_type_node
13202           || rhs_type == promoted_boolean_type_node))
13203     return 1;
13204
13205   /* From here, an integral is widened if its precision is smaller
13206      than the precision of the LHS or if the LHS is a floating point
13207      type, or the RHS is a float and the RHS a double. */
13208   if ((JINTEGRAL_TYPE_P (rhs_type) && JINTEGRAL_TYPE_P (lhs_type)
13209        && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
13210       || (JINTEGRAL_TYPE_P (rhs_type) && JFLOAT_TYPE_P (lhs_type))
13211       || (rhs_type == float_type_node && lhs_type == double_type_node))
13212     return 1;
13213
13214   return 0;
13215 }
13216
13217 /* Check that something of SOURCE type can be assigned or cast to
13218    something of DEST type at runtime. Return 1 if the operation is
13219    valid, 0 otherwise. If CAST is set to 1, we're treating the case
13220    were SOURCE is cast into DEST, which borrows a lot of the
13221    assignment check. */
13222
13223 static int
13224 valid_ref_assignconv_cast_p (tree source, tree dest, int cast)
13225 {
13226   /* SOURCE or DEST might be null if not from a declared entity. */
13227   if (!source || !dest)
13228     return 0;
13229   if (JNULLP_TYPE_P (source))
13230     return 1;
13231   if (TREE_CODE (source) == POINTER_TYPE)
13232     source = TREE_TYPE (source);
13233   if (TREE_CODE (dest) == POINTER_TYPE)
13234     dest = TREE_TYPE (dest);
13235
13236   /* If source and dest are being compiled from bytecode, they may need to
13237      be loaded. */
13238   if (CLASS_P (source) && !CLASS_LOADED_P (source))
13239     {
13240       load_class (source, 1);
13241       safe_layout_class (source);
13242     }
13243   if (CLASS_P (dest) && !CLASS_LOADED_P (dest))
13244     {
13245       load_class (dest, 1);
13246       safe_layout_class (dest);
13247     }
13248
13249   /* Case where SOURCE is a class type */
13250   if (TYPE_CLASS_P (source))
13251     {
13252       if (TYPE_CLASS_P (dest))
13253         return  (source == dest
13254                  || inherits_from_p (source, dest)
13255                  || (cast && inherits_from_p (dest, source)));
13256       if (TYPE_INTERFACE_P (dest))
13257         {
13258           /* If doing a cast and SOURCE is final, the operation is
13259              always correct a compile time (because even if SOURCE
13260              does not implement DEST, a subclass of SOURCE might). */
13261           if (cast && !CLASS_FINAL (TYPE_NAME (source)))
13262             return 1;
13263           /* Otherwise, SOURCE must implement DEST */
13264           return interface_of_p (dest, source);
13265         }
13266       /* DEST is an array, cast permitted if SOURCE is of Object type */
13267       return (cast && source == object_type_node ? 1 : 0);
13268     }
13269   if (TYPE_INTERFACE_P (source))
13270     {
13271       if (TYPE_CLASS_P (dest))
13272         {
13273           /* If not casting, DEST must be the Object type */
13274           if (!cast)
13275             return dest == object_type_node;
13276           /* We're doing a cast. The cast is always valid is class
13277              DEST is not final, otherwise, DEST must implement SOURCE */
13278           else if (!CLASS_FINAL (TYPE_NAME (dest)))
13279             return 1;
13280           else
13281             return interface_of_p (source, dest);
13282         }
13283       if (TYPE_INTERFACE_P (dest))
13284         {
13285           /* If doing a cast, then if SOURCE and DEST contain method
13286              with the same signature but different return type, then
13287              this is a (compile time) error */
13288           if (cast)
13289             {
13290               tree method_source, method_dest;
13291               tree source_type;
13292               tree source_sig;
13293               tree source_name;
13294               for (method_source = TYPE_METHODS (source); method_source;
13295                    method_source = TREE_CHAIN (method_source))
13296                 {
13297                   source_sig =
13298                     build_java_argument_signature (TREE_TYPE (method_source));
13299                   source_type = TREE_TYPE (TREE_TYPE (method_source));
13300                   source_name = DECL_NAME (method_source);
13301                   for (method_dest = TYPE_METHODS (dest);
13302                        method_dest; method_dest = TREE_CHAIN (method_dest))
13303                     if (source_sig ==
13304                         build_java_argument_signature (TREE_TYPE (method_dest))
13305                         && source_name == DECL_NAME (method_dest)
13306                         && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
13307                       return 0;
13308                 }
13309               return 1;
13310             }
13311           else
13312             return source == dest || interface_of_p (dest, source);
13313         }
13314       else
13315         {
13316           /* Array */
13317           return (cast
13318                   && (DECL_NAME (TYPE_NAME (source))
13319                       == java_lang_cloneable_identifier_node
13320                       || (DECL_NAME (TYPE_NAME (source))
13321                           == java_io_serializable_identifier_node)));
13322         }
13323     }
13324   if (TYPE_ARRAY_P (source))
13325     {
13326       if (TYPE_CLASS_P (dest))
13327         return dest == object_type_node;
13328       /* Can't cast an array to an interface unless the interface is
13329          java.lang.Cloneable or java.io.Serializable.  */
13330       if (TYPE_INTERFACE_P (dest))
13331         return (DECL_NAME (TYPE_NAME (dest))
13332                 == java_lang_cloneable_identifier_node
13333                 || (DECL_NAME (TYPE_NAME (dest))
13334                     == java_io_serializable_identifier_node));
13335       else                      /* Arrays */
13336         {
13337           tree source_element_type = TYPE_ARRAY_ELEMENT (source);
13338           tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
13339
13340           /* In case of severe errors, they turn out null */
13341           if (!dest_element_type || !source_element_type)
13342             return 0;
13343           if (source_element_type == dest_element_type)
13344             return 1;
13345           return valid_ref_assignconv_cast_p (source_element_type,
13346                                               dest_element_type, cast);
13347         }
13348       return 0;
13349     }
13350   return 0;
13351 }
13352
13353 static int
13354 valid_cast_to_p (tree source, tree dest)
13355 {
13356   if (TREE_CODE (source) == POINTER_TYPE)
13357     source = TREE_TYPE (source);
13358   if (TREE_CODE (dest) == POINTER_TYPE)
13359     dest = TREE_TYPE (dest);
13360
13361   if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
13362     return valid_ref_assignconv_cast_p (source, dest, 1);
13363
13364   else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
13365     return 1;
13366
13367   else if (TREE_CODE (source) == BOOLEAN_TYPE
13368            && TREE_CODE (dest) == BOOLEAN_TYPE)
13369     return 1;
13370
13371   return 0;
13372 }
13373
13374 static tree
13375 do_unary_numeric_promotion (tree arg)
13376 {
13377   tree type = TREE_TYPE (arg);
13378   if (TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
13379     arg = convert (int_type_node, arg);
13380   return arg;
13381 }
13382
13383 /* Return a nonzero value if SOURCE can be converted into DEST using
13384    the method invocation conversion rule (5.3).  */
13385 static int
13386 valid_method_invocation_conversion_p (tree dest, tree source)
13387 {
13388   return ((JPRIMITIVE_TYPE_P (source) && JPRIMITIVE_TYPE_P (dest)
13389            && valid_builtin_assignconv_identity_widening_p (dest, source))
13390           || ((JREFERENCE_TYPE_P (source) || JNULLP_TYPE_P (source))
13391               && (JREFERENCE_TYPE_P (dest) || JNULLP_TYPE_P (dest))
13392               && valid_ref_assignconv_cast_p (source, dest, 0)));
13393 }
13394
13395 /* Build an incomplete binop expression. */
13396
13397 static tree
13398 build_binop (enum tree_code op, int op_location, tree op1, tree op2)
13399 {
13400   tree binop = build2 (op, NULL_TREE, op1, op2);
13401   TREE_SIDE_EFFECTS (binop) = 1;
13402   /* Store the location of the operator, for better error report. The
13403      string of the operator will be rebuild based on the OP value. */
13404   EXPR_WFL_LINECOL (binop) = op_location;
13405   return binop;
13406 }
13407
13408 /* Build the string of the operator retained by NODE. If NODE is part
13409    of a compound expression, add an '=' at the end of the string. This
13410    function is called when an error needs to be reported on an
13411    operator. The string is returned as a pointer to a static character
13412    buffer. */
13413
13414 static char *
13415 operator_string (tree node)
13416 {
13417 #define BUILD_OPERATOR_STRING(S)                                        \
13418   {                                                                     \
13419     sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
13420     return buffer;                                                      \
13421   }
13422
13423   static char buffer [10];
13424   switch (TREE_CODE (node))
13425     {
13426     case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
13427     case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
13428     case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
13429     case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13430     case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
13431     case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
13432     case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
13433     case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
13434     case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
13435     case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
13436     case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
13437     case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
13438     case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
13439     case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
13440     case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
13441     case GT_EXPR: BUILD_OPERATOR_STRING (">");
13442     case GE_EXPR: BUILD_OPERATOR_STRING (">=");
13443     case LT_EXPR: BUILD_OPERATOR_STRING ("<");
13444     case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
13445     case UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
13446     case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
13447     case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
13448     case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
13449     case PREINCREMENT_EXPR:     /* Fall through */
13450     case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
13451     case PREDECREMENT_EXPR:     /* Fall through */
13452     case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
13453     default:
13454       internal_error ("unregistered operator %s",
13455                       tree_code_name [TREE_CODE (node)]);
13456     }
13457   return NULL;
13458 #undef BUILD_OPERATOR_STRING
13459 }
13460
13461 /* Return 1 if VAR_ACCESS1 is equivalent to VAR_ACCESS2.  */
13462
13463 static int
13464 java_decl_equiv (tree var_acc1, tree var_acc2)
13465 {
13466   if (JDECL_P (var_acc1))
13467     return (var_acc1 == var_acc2);
13468
13469   return (TREE_CODE (var_acc1) == COMPONENT_REF
13470           && TREE_CODE (var_acc2) == COMPONENT_REF
13471           && TREE_OPERAND (TREE_OPERAND (var_acc1, 0), 0)
13472              == TREE_OPERAND (TREE_OPERAND (var_acc2, 0), 0)
13473           && TREE_OPERAND (var_acc1, 1) == TREE_OPERAND (var_acc2, 1));
13474 }
13475
13476 /* Return a nonzero value if CODE is one of the operators that can be
13477    used in conjunction with the `=' operator in a compound assignment.  */
13478
13479 static int
13480 binop_compound_p (enum tree_code code)
13481 {
13482   int i;
13483   for (i = 0; i < BINOP_COMPOUND_CANDIDATES; i++)
13484     if (binop_lookup [i] == code)
13485       break;
13486
13487   return i < BINOP_COMPOUND_CANDIDATES;
13488 }
13489
13490 /* Reorganize after a fold to get SAVE_EXPR to generate what we want.  */
13491
13492 static tree
13493 java_refold (tree t)
13494 {
13495   tree c, b, ns, decl;
13496
13497   if (TREE_CODE (t) != MODIFY_EXPR)
13498     return t;
13499
13500   c = TREE_OPERAND (t, 1);
13501   if (! (c && TREE_CODE (c) == COMPOUND_EXPR
13502          && TREE_CODE (TREE_OPERAND (c, 0)) == MODIFY_EXPR
13503          && binop_compound_p (TREE_CODE (TREE_OPERAND (c, 1)))))
13504     return t;
13505
13506   /* Now the left branch of the binary operator. */
13507   b = TREE_OPERAND (TREE_OPERAND (c, 1), 0);
13508   if (! (b && TREE_CODE (b) == NOP_EXPR
13509          && TREE_CODE (TREE_OPERAND (b, 0)) == SAVE_EXPR))
13510     return t;
13511
13512   ns = TREE_OPERAND (TREE_OPERAND (b, 0), 0);
13513   if (! (ns && TREE_CODE (ns) == NOP_EXPR
13514          && TREE_CODE (TREE_OPERAND (ns, 0)) == SAVE_EXPR))
13515     return t;
13516
13517   decl = TREE_OPERAND (TREE_OPERAND (ns, 0), 0);
13518   if ((JDECL_P (decl) || TREE_CODE (decl) == COMPONENT_REF)
13519       /* It's got to be the an equivalent decl */
13520       && java_decl_equiv (decl, TREE_OPERAND (TREE_OPERAND (c, 0), 0)))
13521     {
13522       /* Shorten the NOP_EXPR/SAVE_EXPR path. */
13523       TREE_OPERAND (TREE_OPERAND (c, 1), 0) = TREE_OPERAND (ns, 0);
13524       /* Substitute the COMPOUND_EXPR by the BINOP_EXPR */
13525       TREE_OPERAND (t, 1) = TREE_OPERAND (c, 1);
13526       /* Change the right part of the BINOP_EXPR */
13527       TREE_OPERAND (TREE_OPERAND (t, 1), 1) = TREE_OPERAND (c, 0);
13528     }
13529
13530   return t;
13531 }
13532
13533 /* Binary operators (15.16 up to 15.18). We return error_mark_node on
13534    errors but we modify NODE so that it contains the type computed
13535    according to the expression, when it's fixed. Otherwise, we write
13536    error_mark_node as the type. It allows us to further the analysis
13537    of remaining nodes and detects more errors in certain cases.  */
13538
13539 static tree
13540 patch_binop (tree node, tree wfl_op1, tree wfl_op2, int folding)
13541 {
13542   tree op1 = TREE_OPERAND (node, 0);
13543   tree op2 = TREE_OPERAND (node, 1);
13544   tree op1_type = TREE_TYPE (op1);
13545   tree op2_type = TREE_TYPE (op2);
13546   tree prom_type = NULL_TREE, cn;
13547   enum tree_code code = TREE_CODE (node);
13548
13549   /* If 1, tell the routine that we have to return error_mark_node
13550      after checking for the initialization of the RHS */
13551   int error_found = 0;
13552
13553   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
13554
13555   /* If either op<n>_type are NULL, this might be early signs of an
13556      error situation, unless it's too early to tell (in case we're
13557      handling a `+', `==', `!=' or `instanceof'.) We want to set op<n>_type
13558      correctly so the error can be later on reported accurately. */
13559   if (! (code == PLUS_EXPR || code == NE_EXPR
13560          || code == EQ_EXPR || code == INSTANCEOF_EXPR))
13561     {
13562       tree n;
13563       if (! op1_type)
13564         {
13565           n = java_complete_tree (op1);
13566           op1_type = TREE_TYPE (n);
13567         }
13568       if (! op2_type)
13569         {
13570           n = java_complete_tree (op2);
13571           op2_type = TREE_TYPE (n);
13572         }
13573     }
13574
13575   switch (code)
13576     {
13577     /* 15.16 Multiplicative operators */
13578     case MULT_EXPR:             /* 15.16.1 Multiplication Operator * */
13579     case RDIV_EXPR:             /* 15.16.2 Division Operator / */
13580     case TRUNC_DIV_EXPR:        /* 15.16.2 Integral type Division Operator / */
13581     case TRUNC_MOD_EXPR:        /* 15.16.3 Remainder operator % */
13582       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13583         {
13584           if (!JNUMERIC_TYPE_P (op1_type))
13585             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13586           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13587             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13588           TREE_TYPE (node) = error_mark_node;
13589           error_found = 1;
13590           break;
13591         }
13592       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13593
13594       /* Detect integral division by zero */
13595       if ((code == RDIV_EXPR || code == TRUNC_MOD_EXPR)
13596           && TREE_CODE (prom_type) == INTEGER_TYPE
13597           && (op2 == integer_zero_node || op2 == long_zero_node ||
13598               (TREE_CODE (op2) == INTEGER_CST &&
13599                ! TREE_INT_CST_LOW (op2)  && ! TREE_INT_CST_HIGH (op2))))
13600         {
13601           parse_warning_context
13602             (wfl_operator,
13603              "Evaluating this expression will result in an arithmetic exception being thrown");
13604           TREE_CONSTANT (node) = 0;
13605           TREE_INVARIANT (node) = 0;
13606         }
13607
13608       /* Change the division operator if necessary */
13609       if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
13610         TREE_SET_CODE (node, TRUNC_DIV_EXPR);
13611
13612       /* Before divisions as is disappear, try to simplify and bail if
13613          applicable, otherwise we won't perform even simple
13614          simplifications like (1-1)/3. We can't do that with floating
13615          point number, folds can't handle them at this stage. */
13616       if (code == RDIV_EXPR && TREE_CONSTANT (op1) && TREE_CONSTANT (op2)
13617           && JINTEGRAL_TYPE_P (op1) && JINTEGRAL_TYPE_P (op2))
13618         {
13619           TREE_TYPE (node) = prom_type;
13620           node = fold (node);
13621           if (TREE_CODE (node) != code)
13622             return node;
13623         }
13624
13625       if (TREE_CODE (prom_type) == INTEGER_TYPE
13626           && flag_use_divide_subroutine
13627           && ! flag_emit_class_files
13628           && (code == RDIV_EXPR || code == TRUNC_MOD_EXPR))
13629         return build_java_soft_divmod (TREE_CODE (node), prom_type, op1, op2);
13630
13631       /* This one is more complicated. FLOATs are processed by a
13632          function call to soft_fmod. Duplicate the value of the
13633          COMPOUND_ASSIGN_P flag. */
13634       if (code == TRUNC_MOD_EXPR)
13635         {
13636           tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
13637           COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
13638           return mod;
13639         }
13640       break;
13641
13642     /* 15.17 Additive Operators */
13643     case PLUS_EXPR:             /* 15.17.1 String Concatenation Operator + */
13644
13645       /* Operation is valid if either one argument is a string
13646          constant, a String object or a StringBuffer crafted for the
13647          purpose of the a previous usage of the String concatenation
13648          operator */
13649
13650       if (TREE_CODE (op1) == STRING_CST
13651           || TREE_CODE (op2) == STRING_CST
13652           || JSTRING_TYPE_P (op1_type)
13653           || JSTRING_TYPE_P (op2_type)
13654           || IS_CRAFTED_STRING_BUFFER_P (op1)
13655           || IS_CRAFTED_STRING_BUFFER_P (op2))
13656         return build_string_concatenation (op1, op2);
13657
13658     case MINUS_EXPR:            /* 15.17.2 Additive Operators (+ and -) for
13659                                    Numeric Types */
13660       if (!JNUMERIC_TYPE_P (op1_type) || !JNUMERIC_TYPE_P (op2_type))
13661         {
13662           if (!JNUMERIC_TYPE_P (op1_type))
13663             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13664           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13665             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13666           TREE_TYPE (node) = error_mark_node;
13667           error_found = 1;
13668           break;
13669         }
13670       prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13671       break;
13672
13673     /* 15.18 Shift Operators */
13674     case LSHIFT_EXPR:
13675     case RSHIFT_EXPR:
13676     case URSHIFT_EXPR:
13677       if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
13678         {
13679           if (!JINTEGRAL_TYPE_P (op1_type))
13680             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13681           else
13682             {
13683               if (JNUMERIC_TYPE_P (op2_type))
13684                 parse_error_context (wfl_operator,
13685                                      "Incompatible type for %qs. Explicit cast needed to convert shift distance from %qs to integral",
13686                                      operator_string (node),
13687                                      lang_printable_name (op2_type, 0));
13688               else
13689                 parse_error_context (wfl_operator,
13690                                      "Incompatible type for %qs. Can't convert shift distance from %qs to integral",
13691                                      operator_string (node),
13692                                      lang_printable_name (op2_type, 0));
13693             }
13694           TREE_TYPE (node) = error_mark_node;
13695           error_found = 1;
13696           break;
13697         }
13698
13699       /* Unary numeric promotion (5.6.1) is performed on each operand
13700          separately */
13701       op1 = do_unary_numeric_promotion (op1);
13702       op2 = do_unary_numeric_promotion (op2);
13703
13704       /* If the right hand side is of type `long', first cast it to
13705          `int'.  */
13706       if (TREE_TYPE (op2) == long_type_node)
13707         op2 = build1 (CONVERT_EXPR, int_type_node, op2);
13708
13709       /* The type of the shift expression is the type of the promoted
13710          type of the left-hand operand */
13711       prom_type = TREE_TYPE (op1);
13712
13713       /* Shift int only up to 0x1f and long up to 0x3f */
13714       if (prom_type == int_type_node)
13715         op2 = fold_build2 (BIT_AND_EXPR, int_type_node, op2,
13716                            build_int_cst (NULL_TREE, 0x1f));
13717       else
13718         op2 = fold_build2 (BIT_AND_EXPR, int_type_node, op2,
13719                            build_int_cst (NULL_TREE, 0x3f));
13720
13721       /* The >>> operator is a >> operating on unsigned quantities */
13722       if (code == URSHIFT_EXPR && (folding || ! flag_emit_class_files))
13723         {
13724           tree to_return;
13725           tree utype = java_unsigned_type (prom_type);
13726           op1 = convert (utype, op1);
13727
13728           to_return = fold_build2 (RSHIFT_EXPR, utype, op1, op2);
13729           to_return = convert (prom_type, to_return);
13730           /* Copy the original value of the COMPOUND_ASSIGN_P flag */
13731           COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
13732           TREE_SIDE_EFFECTS (to_return)
13733             = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13734           return to_return;
13735         }
13736       break;
13737
13738       /* 15.19.1 Type Comparison Operator instanceof */
13739     case INSTANCEOF_EXPR:
13740
13741       TREE_TYPE (node) = boolean_type_node;
13742
13743       /* OP1_TYPE might be NULL when OP1 is a string constant.  */
13744       if ((cn = patch_string (op1)))
13745         {
13746           op1 = cn;
13747           op1_type = TREE_TYPE (op1);
13748         }
13749       if (op1_type == NULL_TREE)
13750         abort ();
13751
13752       if (!(op2_type = resolve_type_during_patch (op2)))
13753         return error_mark_node;
13754
13755       /* The first operand must be a reference type or the null type */
13756       if (!JREFERENCE_TYPE_P (op1_type) && op1 != null_pointer_node)
13757         error_found = 1;        /* Error reported further below */
13758
13759       /* The second operand must be a reference type */
13760       if (!JREFERENCE_TYPE_P (op2_type))
13761         {
13762           SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
13763           parse_error_context
13764             (wfl_operator, "Invalid argument %qs for %<instanceof%>",
13765              lang_printable_name (op2_type, 0));
13766           error_found = 1;
13767         }
13768
13769       if (!error_found && valid_ref_assignconv_cast_p (op1_type, op2_type, 1))
13770         {
13771           /* If the first operand is null, the result is always false */
13772           if (op1 == null_pointer_node)
13773             return boolean_false_node;
13774           else if (flag_emit_class_files)
13775             {
13776               TREE_OPERAND (node, 1) = op2_type;
13777               TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
13778               return node;
13779             }
13780           /* Otherwise we have to invoke instance of to figure it out */
13781           else
13782             return build_instanceof (op1, op2_type);
13783         }
13784       /* There is no way the expression operand can be an instance of
13785          the type operand. This is a compile time error. */
13786       else
13787         {
13788           char *t1 = xstrdup (lang_printable_name (op1_type, 0));
13789           SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
13790           parse_error_context
13791             (wfl_operator, "Impossible for %qs to be instance of %qs",
13792              t1, lang_printable_name (op2_type, 0));
13793           free (t1);
13794           error_found = 1;
13795         }
13796
13797       break;
13798
13799       /* 15.21 Bitwise and Logical Operators */
13800     case BIT_AND_EXPR:
13801     case BIT_XOR_EXPR:
13802     case BIT_IOR_EXPR:
13803       if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
13804         /* Binary numeric promotion is performed on both operand and the
13805            expression retain that type */
13806         prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13807
13808       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
13809                && TREE_CODE (op1_type) == BOOLEAN_TYPE)
13810         /* The type of the bitwise operator expression is BOOLEAN */
13811         prom_type = boolean_type_node;
13812       else
13813         {
13814           if (!JINTEGRAL_TYPE_P (op1_type))
13815             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
13816           if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
13817             ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
13818           TREE_TYPE (node) = error_mark_node;
13819           error_found = 1;
13820           /* Insert a break here if adding thing before the switch's
13821              break for this case */
13822         }
13823       break;
13824
13825       /* 15.22 Conditional-And Operator */
13826     case TRUTH_ANDIF_EXPR:
13827       /* 15.23 Conditional-Or Operator */
13828     case TRUTH_ORIF_EXPR:
13829       /* Operands must be of BOOLEAN type */
13830       if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
13831           TREE_CODE (op2_type) != BOOLEAN_TYPE)
13832         {
13833           if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
13834             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
13835           if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
13836             ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
13837           TREE_TYPE (node) = boolean_type_node;
13838           error_found = 1;
13839           break;
13840         }
13841       else if (integer_zerop (op1))
13842         {
13843           return code == TRUTH_ANDIF_EXPR ? op1 : op2;
13844         }
13845       else if (integer_onep (op1))
13846         {
13847           return code == TRUTH_ANDIF_EXPR ? op2 : op1;
13848         }
13849       /* The type of the conditional operators is BOOLEAN */
13850       prom_type = boolean_type_node;
13851       break;
13852
13853       /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
13854     case LT_EXPR:
13855     case GT_EXPR:
13856     case LE_EXPR:
13857     case GE_EXPR:
13858       /* The type of each of the operands must be a primitive numeric
13859          type */
13860       if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
13861         {
13862           if (!JNUMERIC_TYPE_P (op1_type))
13863             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
13864           if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
13865             ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
13866           TREE_TYPE (node) = boolean_type_node;
13867           error_found = 1;
13868           break;
13869         }
13870       /* Binary numeric promotion is performed on the operands */
13871       binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13872       /* The type of the relation expression is always BOOLEAN */
13873       prom_type = boolean_type_node;
13874       break;
13875
13876       /* 15.20 Equality Operator */
13877     case EQ_EXPR:
13878     case NE_EXPR:
13879       /* It's time for us to patch the strings. */
13880       if ((cn = patch_string (op1)))
13881        {
13882          op1 = cn;
13883          op1_type = TREE_TYPE (op1);
13884        }
13885       if ((cn = patch_string (op2)))
13886        {
13887          op2 = cn;
13888          op2_type = TREE_TYPE (op2);
13889        }
13890
13891       /* 15.20.1 Numerical Equality Operators == and != */
13892       /* Binary numeric promotion is performed on the operands */
13893       if (JNUMERIC_TYPE_P (op1_type) && JNUMERIC_TYPE_P (op2_type))
13894         binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
13895
13896       /* 15.20.2 Boolean Equality Operators == and != */
13897       else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
13898           TREE_CODE (op2_type) == BOOLEAN_TYPE)
13899         ;                       /* Nothing to do here */
13900
13901       /* 15.20.3 Reference Equality Operators == and != */
13902       /* Types have to be either references or the null type. If
13903          they're references, it must be possible to convert either
13904          type to the other by casting conversion. */
13905       else if ((op1 == null_pointer_node && op2 == null_pointer_node)
13906                || (op1 == null_pointer_node && JREFERENCE_TYPE_P (op2_type))
13907                || (JREFERENCE_TYPE_P (op1_type) && op2 == null_pointer_node)
13908                || (JREFERENCE_TYPE_P (op1_type) && JREFERENCE_TYPE_P (op2_type)
13909                    && (valid_ref_assignconv_cast_p (op1_type, op2_type, 1)
13910                        || valid_ref_assignconv_cast_p (op2_type,
13911                                                        op1_type, 1))))
13912         ;                       /* Nothing to do here */
13913
13914       /* Else we have an error figure what can't be converted into
13915          what and report the error */
13916       else
13917         {
13918           char *t1;
13919           t1 = xstrdup (lang_printable_name (op1_type, 0));
13920           parse_error_context
13921             (wfl_operator,
13922              "Incompatible type for %qs. Can't convert %qs to %qs",
13923              operator_string (node), t1,
13924              lang_printable_name (op2_type, 0));
13925           free (t1);
13926           TREE_TYPE (node) = boolean_type_node;
13927           error_found = 1;
13928           break;
13929         }
13930       prom_type = boolean_type_node;
13931       break;
13932     default:
13933       abort ();
13934     }
13935
13936   if (error_found)
13937     return error_mark_node;
13938
13939   TREE_OPERAND (node, 0) = op1;
13940   TREE_OPERAND (node, 1) = op2;
13941   TREE_TYPE (node) = prom_type;
13942   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
13943
13944   /* fold does not respect side-effect order as required for Java but not C.
13945    * Also, it sometimes create SAVE_EXPRs which are bad when emitting
13946    * bytecode.
13947    */
13948   if (flag_emit_class_files ? (TREE_CONSTANT (op1) && TREE_CONSTANT (op2))
13949       : ! TREE_SIDE_EFFECTS (node))
13950     node = fold (node);
13951   return node;
13952 }
13953
13954 /* Concatenate the STRING_CST CSTE and STRING. When AFTER is a non
13955    zero value, the value of CSTE comes after the valude of STRING */
13956
13957 static tree
13958 do_merge_string_cste (tree cste, const char *string, int string_len, int after)
13959 {
13960   const char *old = TREE_STRING_POINTER (cste);
13961   int old_len = TREE_STRING_LENGTH (cste);
13962   int len = old_len + string_len;
13963   char *new = alloca (len+1);
13964
13965   if (after)
13966     {
13967       memcpy (new, string, string_len);
13968       memcpy (&new [string_len], old, old_len);
13969     }
13970   else
13971     {
13972       memcpy (new, old, old_len);
13973       memcpy (&new [old_len], string, string_len);
13974     }
13975   new [len] = '\0';
13976   return build_string (len, new);
13977 }
13978
13979 /* Tries to merge OP1 (a STRING_CST) and OP2 (if suitable). Return a
13980    new STRING_CST on success, NULL_TREE on failure.  */
13981
13982 static tree
13983 merge_string_cste (tree op1, tree op2, int after)
13984 {
13985   /* Handle two string constants right away.  */
13986   if (TREE_CODE (op2) == STRING_CST)
13987     return do_merge_string_cste (op1, TREE_STRING_POINTER (op2),
13988                                  TREE_STRING_LENGTH (op2), after);
13989
13990   /* Reasonable integer constant can be treated right away.  */
13991   if (TREE_CODE (op2) == INTEGER_CST && !TREE_CONSTANT_OVERFLOW (op2))
13992     {
13993       static const char *const boolean_true = "true";
13994       static const char *const boolean_false = "false";
13995       static const char *const null_pointer = "null";
13996       char ch[4];
13997       const char *string;
13998
13999       if (op2 == boolean_true_node)
14000         string = boolean_true;
14001       else if (op2 == boolean_false_node)
14002         string = boolean_false;
14003       else if (op2 == null_pointer_node
14004                || (integer_zerop (op2)
14005                    && TREE_CODE (TREE_TYPE (op2)) == POINTER_TYPE))
14006         /* FIXME: null is not a compile-time constant, so it is only safe to
14007            merge if the overall expression is non-constant. However, this
14008            code always merges without checking the overall expression.  */
14009         string = null_pointer;
14010       else if (TREE_TYPE (op2) == char_type_node)
14011         {
14012           /* Convert the character into UTF-8.  */
14013           unsigned int c = (unsigned int) TREE_INT_CST_LOW (op2);
14014           unsigned char *p = (unsigned char *) ch;
14015           if (0x01 <= c && c <= 0x7f)
14016             *p++ = (unsigned char) c;
14017           else if (c < 0x7ff)
14018             {
14019               *p++ = (unsigned char) (c >> 6 | 0xc0);
14020               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
14021             }
14022           else
14023             {
14024               *p++ = (unsigned char) (c >> 12 | 0xe0);
14025               *p++ = (unsigned char) (((c >> 6) & 0x3f) | 0x80);
14026               *p++ = (unsigned char) ((c & 0x3f) | 0x80);
14027             }
14028           *p = '\0';
14029
14030           string = ch;
14031         }
14032       else
14033         string = string_convert_int_cst (op2);
14034
14035       return do_merge_string_cste (op1, string, strlen (string), after);
14036     }
14037   return NULL_TREE;
14038 }
14039
14040 /* Tries to statically concatenate OP1 and OP2 if possible. Either one
14041    has to be a STRING_CST and the other part must be a STRING_CST or a
14042    INTEGRAL constant. Return a new STRING_CST if the operation
14043    succeed, NULL_TREE otherwise.
14044
14045    If the case we want to optimize for space, we might want to return
14046    NULL_TREE for each invocation of this routine. FIXME */
14047
14048 static tree
14049 string_constant_concatenation (tree op1, tree op2)
14050 {
14051   if (TREE_CODE (op1) == STRING_CST || (TREE_CODE (op2) == STRING_CST))
14052     {
14053       tree string, rest;
14054       int invert;
14055
14056       string = (TREE_CODE (op1) == STRING_CST ? op1 : op2);
14057       rest   = (string == op1 ? op2 : op1);
14058       invert = (string == op1 ? 0 : 1 );
14059
14060       /* Walk REST, only if it looks reasonable */
14061       if (TREE_CODE (rest) != STRING_CST
14062           && !IS_CRAFTED_STRING_BUFFER_P (rest)
14063           && !JSTRING_TYPE_P (TREE_TYPE (rest))
14064           && TREE_CODE (rest) == EXPR_WITH_FILE_LOCATION)
14065         {
14066           rest = java_complete_tree (rest);
14067           if (rest == error_mark_node)
14068             return error_mark_node;
14069           rest = fold (rest);
14070         }
14071       return merge_string_cste (string, rest, invert);
14072     }
14073   return NULL_TREE;
14074 }
14075
14076 /* Implement the `+' operator. Does static optimization if possible,
14077    otherwise create (if necessary) and append elements to a
14078    StringBuffer. The StringBuffer will be carried around until it is
14079    used for a function call or an assignment. Then toString() will be
14080    called on it to turn it into a String object. */
14081
14082 static tree
14083 build_string_concatenation (tree op1, tree op2)
14084 {
14085   tree result;
14086   int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
14087
14088   /* Try to do some static optimization */
14089   if ((result = string_constant_concatenation (op1, op2)))
14090     return result;
14091
14092   /* Discard empty strings on either side of the expression */
14093   if (TREE_CODE (op1) == STRING_CST && TREE_STRING_LENGTH (op1) == 0)
14094     {
14095       op1 = op2;
14096       op2 = NULL_TREE;
14097     }
14098   else if (TREE_CODE (op2) == STRING_CST && TREE_STRING_LENGTH (op2) == 0)
14099     op2 = NULL_TREE;
14100
14101   /* If operands are string constant, turn then into object references */
14102   if (TREE_CODE (op1) == STRING_CST)
14103     op1 = patch_string_cst (op1);
14104   if (op2 && TREE_CODE (op2) == STRING_CST)
14105     op2 = patch_string_cst (op2);
14106
14107   /* If either one of the constant is null and the other non null
14108      operand is a String constant, return it. */
14109   if ((TREE_CODE (op1) == STRING_CST) && !op2)
14110     return op1;
14111
14112   /* If OP1 isn't already a StringBuffer, create and
14113      initialize a new one */
14114   if (!IS_CRAFTED_STRING_BUFFER_P (op1))
14115     {
14116       /* Two solutions here:
14117          1) OP1 is a constant string reference, we call new StringBuffer(OP1)
14118          2) OP1 is something else, we call new StringBuffer().append(OP1).  */
14119       if (TREE_CONSTANT (op1) && JSTRING_TYPE_P (TREE_TYPE (op1)))
14120         op1 = BUILD_STRING_BUFFER (op1);
14121       else
14122         {
14123           tree aNew = BUILD_STRING_BUFFER (NULL_TREE);
14124           op1 = make_qualified_primary (aNew, BUILD_APPEND (op1), 0);
14125         }
14126     }
14127
14128   if (op2)
14129     {
14130       /* OP1 is no longer the last node holding a crafted StringBuffer */
14131       IS_CRAFTED_STRING_BUFFER_P (op1) = 0;
14132       /* Create a node for `{new...,xxx}.append (op2)' */
14133       op1 = make_qualified_primary (op1, BUILD_APPEND (op2), 0);
14134     }
14135
14136   /* Mark the last node holding a crafted StringBuffer */
14137   IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
14138
14139   TREE_SIDE_EFFECTS (op1) = side_effects;
14140   return op1;
14141 }
14142
14143 /* Patch the string node NODE. NODE can be a STRING_CST of a crafted
14144    StringBuffer. If no string were found to be patched, return
14145    NULL. */
14146
14147 static tree
14148 patch_string (tree node)
14149 {
14150   if (node == error_mark_node)
14151     return error_mark_node;
14152   if (TREE_CODE (node) == STRING_CST)
14153     return patch_string_cst (node);
14154   else if (IS_CRAFTED_STRING_BUFFER_P (node))
14155     {
14156       int saved = ctxp->explicit_constructor_p;
14157       tree invoke = build_method_invocation (wfl_to_string, NULL_TREE);
14158       tree ret;
14159       /* Temporary disable forbid the use of `this'. */
14160       ctxp->explicit_constructor_p = 0;
14161       ret = java_complete_tree (make_qualified_primary (node, invoke, 0));
14162       /* String concatenation arguments must be evaluated in order too. */
14163       ret = force_evaluation_order (ret);
14164       /* Restore it at its previous value */
14165       ctxp->explicit_constructor_p = saved;
14166       return ret;
14167     }
14168   return NULL_TREE;
14169 }
14170
14171 /* Build the internal representation of a string constant.  */
14172
14173 static tree
14174 patch_string_cst (tree node)
14175 {
14176   int location;
14177   if (! flag_emit_class_files)
14178     {
14179       node = get_identifier (TREE_STRING_POINTER (node));
14180       location = alloc_name_constant (CONSTANT_String, node);
14181       node = build_ref_from_constant_pool (location);
14182     }
14183   TREE_CONSTANT (node) = 1;
14184   TREE_INVARIANT (node) = 1;
14185
14186   /* ??? Guessing that the class file code can't handle casts.  */
14187   if (! flag_emit_class_files)
14188     node = convert (string_ptr_type_node, node);
14189   else
14190     TREE_TYPE (node) = string_ptr_type_node;
14191
14192   return node;
14193 }
14194
14195 /* Build an incomplete unary operator expression. */
14196
14197 static tree
14198 build_unaryop (int op_token, int op_location, tree op1)
14199 {
14200   enum tree_code op;
14201   tree unaryop;
14202   switch (op_token)
14203     {
14204     case PLUS_TK: op = UNARY_PLUS_EXPR; break;
14205     case MINUS_TK: op = NEGATE_EXPR; break;
14206     case NEG_TK: op = TRUTH_NOT_EXPR; break;
14207     case NOT_TK: op = BIT_NOT_EXPR; break;
14208     default: abort ();
14209     }
14210
14211   unaryop = build1 (op, NULL_TREE, op1);
14212   TREE_SIDE_EFFECTS (unaryop) = 1;
14213   /* Store the location of the operator, for better error report. The
14214      string of the operator will be rebuild based on the OP value. */
14215   EXPR_WFL_LINECOL (unaryop) = op_location;
14216   return unaryop;
14217 }
14218
14219 /* Special case for the ++/-- operators, since they require an extra
14220    argument to build, which is set to NULL and patched
14221    later. IS_POST_P is 1 if the operator, 0 otherwise.  */
14222
14223 static tree
14224 build_incdec (int op_token, int op_location, tree op1, int is_post_p)
14225 {
14226   static const enum tree_code lookup [2][2] =
14227     {
14228       { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
14229       { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
14230     };
14231   tree node = build2 (lookup [is_post_p][(op_token - DECR_TK)],
14232                       NULL_TREE, op1, NULL_TREE);
14233   TREE_SIDE_EFFECTS (node) = 1;
14234   /* Store the location of the operator, for better error report. The
14235      string of the operator will be rebuild based on the OP value. */
14236   EXPR_WFL_LINECOL (node) = op_location;
14237
14238   /* Report an error if the operand is a constant. */
14239   if (TREE_CONSTANT (op1)) {
14240     parse_error_context (node, "%qs cannot be used with a constant",
14241                          operator_string (node));
14242     return error_mark_node;
14243   }
14244
14245   return node;
14246 }
14247
14248 /* Build an incomplete cast operator, based on the use of the
14249    CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
14250    set. java_complete_tree is trained to walk a CONVERT_EXPR even
14251    though its type is already set.  */
14252
14253 static tree
14254 build_cast (int location, tree type, tree exp)
14255 {
14256   tree node = build1 (CONVERT_EXPR, type, exp);
14257   EXPR_WFL_LINECOL (node) = location;
14258   return node;
14259 }
14260
14261 /* Build an incomplete class reference operator.  */
14262 static tree
14263 build_incomplete_class_ref (int location, tree class_name)
14264 {
14265   tree node = build1 (CLASS_LITERAL, NULL_TREE, class_name);
14266   tree class_decl = GET_CPC ();
14267   tree this_class = TREE_TYPE (class_decl);
14268
14269   /* Generate the synthetic static method `class$'.  (Previously we
14270      deferred this, causing different method tables to be emitted
14271      for native code and bytecode.)  */
14272   if (!TYPE_DOT_CLASS (this_class)
14273       && !JPRIMITIVE_TYPE_P (class_name)
14274       && !(TREE_CODE (class_name) == VOID_TYPE))
14275     {
14276       tree cpc_list = GET_CPC_LIST();
14277       tree cpc = cpc_list;
14278       tree target_class;
14279
14280       /* For inner classes, add a 'class$' method to their outermost
14281          context, creating it if necessary.  */
14282
14283       while (GET_NEXT_ENCLOSING_CPC(cpc))
14284         cpc = GET_NEXT_ENCLOSING_CPC(cpc);
14285       class_decl = TREE_VALUE (cpc);
14286
14287       target_class = TREE_TYPE (class_decl);
14288
14289       if (CLASS_INTERFACE (TYPE_NAME (target_class)))
14290         {
14291           /* For interfaces, adding a static 'class$' method directly
14292              is illegal.  So create an inner class to contain the new
14293              method.  Empirically this matches the behavior of javac.  */
14294           tree t, inner;
14295           /* We want the generated inner class inside the outermost class. */
14296           GET_CPC_LIST() = cpc;
14297           t = build_wfl_node (DECL_NAME (TYPE_NAME (object_type_node)));
14298           inner = create_anonymous_class (t);
14299           target_class = TREE_TYPE (inner);
14300           end_class_declaration (1);
14301           GET_CPC_LIST() = cpc_list;
14302         }
14303
14304       if (TYPE_DOT_CLASS (target_class) == NULL_TREE)
14305         build_dot_class_method (target_class);
14306
14307       if (this_class != target_class)
14308         TYPE_DOT_CLASS (this_class) = TYPE_DOT_CLASS (target_class);
14309     }
14310
14311   EXPR_WFL_LINECOL (node) = location;
14312   return node;
14313 }
14314
14315 /* Complete an incomplete class reference operator.  */
14316 static tree
14317 patch_incomplete_class_ref (tree node)
14318 {
14319   tree type = TREE_OPERAND (node, 0);
14320   tree ref_type;
14321
14322   if (!(ref_type = resolve_type_during_patch (type)))
14323     return error_mark_node;
14324
14325   /* If we're not emitting class files and we know ref_type is a
14326      compiled class, build a direct reference.  */
14327   if ((! flag_emit_class_files && is_compiled_class (ref_type))
14328       || JPRIMITIVE_TYPE_P (ref_type)
14329       || TREE_CODE (ref_type) == VOID_TYPE)
14330     {
14331       tree dot = build_class_ref (ref_type);
14332       /* A class referenced by `foo.class' is initialized.  */
14333       if (!flag_emit_class_files)
14334        dot = build_class_init (ref_type, dot);
14335       return java_complete_tree (dot);
14336     }
14337
14338   /* If we're emitting class files and we have to deal with non
14339      primitive types, we invoke the synthetic static method `class$'.  */
14340   ref_type = build_dot_class_method_invocation (current_class, ref_type);
14341   return java_complete_tree (ref_type);
14342 }
14343
14344 /* 15.14 Unary operators. We return error_mark_node in case of error,
14345    but preserve the type of NODE if the type is fixed.  */
14346
14347 static tree
14348 patch_unaryop (tree node, tree wfl_op)
14349 {
14350   tree op = TREE_OPERAND (node, 0);
14351   tree op_type = TREE_TYPE (op);
14352   tree prom_type = NULL_TREE, value, decl;
14353   int nested_field_flag = 0;
14354   int code = TREE_CODE (node);
14355   int error_found = 0;
14356
14357   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14358
14359   switch (code)
14360     {
14361       /* 15.13.2 Postfix Increment Operator ++ */
14362     case POSTINCREMENT_EXPR:
14363       /* 15.13.3 Postfix Increment Operator -- */
14364     case POSTDECREMENT_EXPR:
14365       /* 15.14.1 Prefix Increment Operator ++ */
14366     case PREINCREMENT_EXPR:
14367       /* 15.14.2 Prefix Decrement Operator -- */
14368     case PREDECREMENT_EXPR:
14369       op = decl = extract_field_decl (op);
14370       nested_field_flag
14371         = nested_field_expanded_access_p (op, NULL, NULL, NULL);
14372       /* We might be trying to change an outer field accessed using
14373          access method. */
14374       if (nested_field_flag)
14375         {
14376           /* Retrieve the decl of the field we're trying to access. We
14377              do that by first retrieving the function we would call to
14378              access the field. It has been already verified that this
14379              field isn't final */
14380           if (flag_emit_class_files)
14381             decl = TREE_OPERAND (op, 0);
14382           else
14383             decl = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (op, 0), 0), 0);
14384           decl = DECL_FUNCTION_ACCESS_DECL (decl);
14385         }
14386       /* We really should have a JAVA_ARRAY_EXPR to avoid this */
14387       else if (!JDECL_P (decl)
14388           && TREE_CODE (decl) != COMPONENT_REF
14389           && !(flag_emit_class_files && TREE_CODE (decl) == ARRAY_REF)
14390           && TREE_CODE (decl) != INDIRECT_REF
14391           && !(TREE_CODE (decl) == COMPOUND_EXPR
14392                && TREE_OPERAND (decl, 1)
14393                && (TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)))
14394         {
14395           TREE_TYPE (node) = error_mark_node;
14396           error_found = 1;
14397         }
14398
14399       /* From now on, we know that op is a variable and that it has a
14400          valid wfl. We use wfl_op to locate errors related to the
14401          ++/-- operand. */
14402       if (!JNUMERIC_TYPE_P (op_type))
14403         {
14404           parse_error_context
14405             (wfl_op, "Invalid argument type %qs to %qs",
14406              lang_printable_name (op_type, 0), operator_string (node));
14407           TREE_TYPE (node) = error_mark_node;
14408           error_found = 1;
14409         }
14410       else
14411         {
14412           /* Before the addition, binary numeric promotion is performed on
14413              both operands, if really necessary */
14414           if (JINTEGRAL_TYPE_P (op_type))
14415             {
14416               value = build_int_cst (op_type, 1);
14417               TREE_TYPE (node) = op_type;
14418             }
14419           else
14420             {
14421               value = build_int_cst (NULL_TREE, 1);
14422               TREE_TYPE (node) =
14423                 binary_numeric_promotion (op_type,
14424                                           TREE_TYPE (value), &op, &value);
14425             }
14426
14427           /* We remember we might be accessing an outer field */
14428           if (nested_field_flag)
14429             {
14430               /* We re-generate an access to the field */
14431               value = build2 (PLUS_EXPR, TREE_TYPE (op),
14432                               build_nested_field_access (wfl_op, decl), value);
14433
14434               /* And we patch the original access$() into a write
14435                  with plus_op as a rhs */
14436               return nested_field_access_fix (node, op, value);
14437             }
14438
14439           /* And write back into the node. */
14440           TREE_OPERAND (node, 0) = op;
14441           TREE_OPERAND (node, 1) = value;
14442           /* Convert the overall back into its original type, if
14443              necessary, and return */
14444           if (JINTEGRAL_TYPE_P (op_type))
14445             return fold (node);
14446           else
14447             return fold (convert (op_type, node));
14448         }
14449       break;
14450
14451       /* 15.14.3 Unary Plus Operator + */
14452     case UNARY_PLUS_EXPR:
14453       /* 15.14.4 Unary Minus Operator - */
14454     case NEGATE_EXPR:
14455       if (!JNUMERIC_TYPE_P (op_type))
14456         {
14457           ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
14458           TREE_TYPE (node) = error_mark_node;
14459           error_found = 1;
14460         }
14461       /* Unary numeric promotion is performed on operand */
14462       else
14463         {
14464           op = do_unary_numeric_promotion (op);
14465           prom_type = TREE_TYPE (op);
14466           if (code == UNARY_PLUS_EXPR)
14467             return fold (op);
14468         }
14469       break;
14470
14471       /* 15.14.5 Bitwise Complement Operator ~ */
14472     case BIT_NOT_EXPR:
14473       if (!JINTEGRAL_TYPE_P (op_type))
14474         {
14475           ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
14476           TREE_TYPE (node) = error_mark_node;
14477           error_found = 1;
14478         }
14479       else
14480         {
14481           op = do_unary_numeric_promotion (op);
14482           prom_type = TREE_TYPE (op);
14483         }
14484       break;
14485
14486       /* 15.14.6 Logical Complement Operator ! */
14487     case TRUTH_NOT_EXPR:
14488       if (TREE_CODE (op_type) != BOOLEAN_TYPE)
14489         {
14490           ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
14491           /* But the type is known. We will report an error if further
14492              attempt of a assignment is made with this rhs */
14493           TREE_TYPE (node) = boolean_type_node;
14494           error_found = 1;
14495         }
14496       else
14497         prom_type = boolean_type_node;
14498       break;
14499
14500       /* 15.15 Cast Expression */
14501     case CONVERT_EXPR:
14502       value = patch_cast (node, wfl_operator);
14503       if (value == error_mark_node)
14504         {
14505           /* If this cast is part of an assignment, we tell the code
14506              that deals with it not to complain about a mismatch,
14507              because things have been cast, anyways */
14508           TREE_TYPE (node) = error_mark_node;
14509           error_found = 1;
14510         }
14511       else
14512         {
14513           value = fold (value);
14514           return value;
14515         }
14516       break;
14517
14518     case NOP_EXPR:
14519       /* This can only happen when the type is already known.  */
14520       gcc_assert (TREE_TYPE (node) != NULL_TREE);
14521       prom_type = TREE_TYPE (node);
14522       break;
14523     }
14524
14525   if (error_found)
14526     return error_mark_node;
14527
14528   /* There are cases where node has been replaced by something else
14529      and we don't end up returning here: UNARY_PLUS_EXPR,
14530      CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
14531   TREE_OPERAND (node, 0) = fold (op);
14532   TREE_TYPE (node) = prom_type;
14533   TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
14534   return fold (node);
14535 }
14536
14537 /* Generic type resolution that sometimes takes place during node
14538    patching. Returned the resolved type or generate an error
14539    message. Return the resolved type or NULL_TREE.  */
14540
14541 static tree
14542 resolve_type_during_patch (tree type)
14543 {
14544   if (unresolved_type_p (type, NULL))
14545     {
14546       tree type_decl = resolve_and_layout (EXPR_WFL_NODE (type), type);
14547       if (!type_decl)
14548         {
14549           parse_error_context (type,
14550                                "Class %qs not found in type declaration",
14551                                IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
14552           return NULL_TREE;
14553         }
14554
14555       check_deprecation (type, type_decl);
14556
14557       return TREE_TYPE (type_decl);
14558     }
14559   return type;
14560 }
14561
14562 /* 5.5 Casting Conversion. error_mark_node is returned if an error is
14563    found. Otherwise NODE or something meant to replace it is returned.  */
14564
14565 static tree
14566 patch_cast (tree node, tree wfl_op)
14567 {
14568   tree op = TREE_OPERAND (node, 0);
14569   tree cast_type = TREE_TYPE (node);
14570   tree patched, op_type;
14571   char *t1;
14572
14573   /* Some string patching might be necessary at this stage */
14574   if ((patched = patch_string (op)))
14575     TREE_OPERAND (node, 0) = op = patched;
14576   op_type = TREE_TYPE (op);
14577
14578   /* First resolve OP_TYPE if unresolved */
14579   if (!(cast_type = resolve_type_during_patch (cast_type)))
14580     return error_mark_node;
14581
14582   /* Check on cast that are proven correct at compile time */
14583   if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
14584     {
14585       /* Same type */
14586       if (cast_type == op_type)
14587         return node;
14588
14589       /* A narrowing conversion from a floating-point number to an
14590          integral type requires special handling (5.1.3).  */
14591       if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
14592         if (cast_type != long_type_node)
14593           op = convert (integer_type_node, op);
14594
14595       /* Try widening/narrowing conversion.  Potentially, things need
14596          to be worked out in gcc so we implement the extreme cases
14597          correctly.  fold_convert() needs to be fixed.  */
14598       return convert (cast_type, op);
14599     }
14600
14601   /* It's also valid to cast a boolean into a boolean */
14602   if (op_type == boolean_type_node && cast_type == boolean_type_node)
14603     return node;
14604
14605   /* null can be casted to references */
14606   if (op == null_pointer_node && JREFERENCE_TYPE_P (cast_type))
14607     return build_null_of_type (cast_type);
14608
14609   /* The remaining legal casts involve conversion between reference
14610      types. Check for their compile time correctness. */
14611   if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
14612       && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
14613     {
14614       TREE_TYPE (node) = promote_type (cast_type);
14615       /* Now, the case can be determined correct at compile time if
14616          OP_TYPE can be converted into CAST_TYPE by assignment
14617          conversion (5.2) */
14618
14619       if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
14620         {
14621           TREE_SET_CODE (node, NOP_EXPR);
14622           return node;
14623         }
14624
14625       if (flag_emit_class_files)
14626         {
14627           TREE_SET_CODE (node, CONVERT_EXPR);
14628           return node;
14629         }
14630
14631       /* The cast requires a run-time check */
14632       return build3 (CALL_EXPR, promote_type (cast_type),
14633                      build_address_of (soft_checkcast_node),
14634                      tree_cons (NULL_TREE, build_class_ref (cast_type),
14635                                 build_tree_list (NULL_TREE, op)),
14636                      NULL_TREE);
14637     }
14638
14639   /* Any other casts are proven incorrect at compile time */
14640   t1 = xstrdup (lang_printable_name (op_type, 0));
14641   parse_error_context (wfl_op, "Invalid cast from %qs to %qs",
14642                        t1, lang_printable_name (cast_type, 0));
14643   free (t1);
14644   return error_mark_node;
14645 }
14646
14647 /* Build a null constant and give it the type TYPE.  */
14648
14649 static tree
14650 build_null_of_type (tree type)
14651 {
14652   tree node = build_int_cst (promote_type (type), 0);
14653   return node;
14654 }
14655
14656 /* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
14657    a list of indices. */
14658 static tree
14659 build_array_ref (int location, tree array, tree index)
14660 {
14661   tree node = build4 (ARRAY_REF, NULL_TREE, array, index,
14662                       NULL_TREE, NULL_TREE);
14663   EXPR_WFL_LINECOL (node) = location;
14664   return node;
14665 }
14666
14667 /* 15.12 Array Access Expression */
14668
14669 static tree
14670 patch_array_ref (tree node)
14671 {
14672   tree array = TREE_OPERAND (node, 0);
14673   tree array_type  = TREE_TYPE (array);
14674   tree index = TREE_OPERAND (node, 1);
14675   tree index_type = TREE_TYPE (index);
14676   int error_found = 0;
14677
14678   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
14679
14680   if (TREE_CODE (array_type) == POINTER_TYPE)
14681     array_type = TREE_TYPE (array_type);
14682
14683   /* The array reference must be an array */
14684   if (!TYPE_ARRAY_P (array_type))
14685     {
14686       parse_error_context
14687         (wfl_operator,
14688          "%<[]%> can only be applied to arrays. It can't be applied to %qs",
14689          lang_printable_name (array_type, 0));
14690       TREE_TYPE (node) = error_mark_node;
14691       error_found = 1;
14692     }
14693
14694   /* The array index undergoes unary numeric promotion. The promoted
14695      type must be int */
14696   index = do_unary_numeric_promotion (index);
14697   if (TREE_TYPE (index) != int_type_node)
14698     {
14699       if (valid_cast_to_p (index_type, int_type_node))
14700         parse_error_context (wfl_operator,
14701    "Incompatible type for %<[]%>. Explicit cast needed to convert %qs to %<int%>",
14702                              lang_printable_name (index_type, 0));
14703       else
14704         parse_error_context (wfl_operator,
14705           "Incompatible type for %<[]%>. Can't convert %qs to %<int%>",
14706                              lang_printable_name (index_type, 0));
14707       TREE_TYPE (node) = error_mark_node;
14708       error_found = 1;
14709     }
14710
14711   if (error_found)
14712     return error_mark_node;
14713
14714   array_type = TYPE_ARRAY_ELEMENT (array_type);
14715
14716   if (flag_emit_class_files)
14717     {
14718       TREE_OPERAND (node, 0) = array;
14719       TREE_OPERAND (node, 1) = index;
14720     }
14721   else
14722     node = build_java_arrayaccess (array, array_type, index);
14723   TREE_TYPE (node) = array_type;
14724   return node;
14725 }
14726
14727 /* 15.9 Array Creation Expressions */
14728
14729 static tree
14730 build_newarray_node (tree type, tree dims, int extra_dims)
14731 {
14732   tree node = build3 (NEW_ARRAY_EXPR, NULL_TREE, type,
14733                       nreverse (dims),
14734                       build_int_cst (NULL_TREE, extra_dims));
14735   return node;
14736 }
14737
14738 static tree
14739 patch_newarray (tree node)
14740 {
14741   tree type = TREE_OPERAND (node, 0);
14742   tree dims = TREE_OPERAND (node, 1);
14743   tree cdim, array_type;
14744   int error_found = 0;
14745   int ndims = 0;
14746   int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
14747
14748   /* Dimension types are verified. It's better for the types to be
14749      verified in order. */
14750   for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
14751     {
14752       int dim_error = 0;
14753       tree dim = TREE_VALUE (cdim);
14754
14755       /* Dim might have been saved during its evaluation */
14756       dim = (TREE_CODE (dim) == SAVE_EXPR ? TREE_OPERAND (dim, 0) : dim);
14757
14758       /* The type of each specified dimension must be an integral type. */
14759       if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
14760         dim_error = 1;
14761
14762       /* Each expression undergoes an unary numeric promotion (5.6.1) and the
14763          promoted type must be int. */
14764       else
14765         {
14766           dim = do_unary_numeric_promotion (dim);
14767           if (TREE_TYPE (dim) != int_type_node)
14768             dim_error = 1;
14769         }
14770
14771       /* Report errors on types here */
14772       if (dim_error)
14773         {
14774           parse_error_context
14775             (TREE_PURPOSE (cdim),
14776              "Incompatible type for dimension in array creation expression. %s convert %qs to %<int%>",
14777              (valid_cast_to_p (TREE_TYPE (dim), int_type_node) ?
14778               "Explicit cast needed to" : "Can't"),
14779              lang_printable_name (TREE_TYPE (dim), 0));
14780           error_found = 1;
14781         }
14782
14783       TREE_PURPOSE (cdim) = NULL_TREE;
14784     }
14785
14786   /* Resolve array base type if unresolved */
14787   if (!(type = resolve_type_during_patch (type)))
14788     error_found = 1;
14789
14790   if (error_found)
14791     {
14792       /* We don't want further evaluation of this bogus array creation
14793          operation */
14794       TREE_TYPE (node) = error_mark_node;
14795       return error_mark_node;
14796     }
14797
14798   /* Set array_type to the actual (promoted) array type of the result. */
14799   if (TREE_CODE (type) == RECORD_TYPE)
14800     type = build_pointer_type (type);
14801   while (--xdims >= 0)
14802     {
14803       type = promote_type (build_java_array_type (type, -1));
14804     }
14805   dims = nreverse (dims);
14806   array_type = type;
14807   for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
14808     {
14809       type = array_type;
14810       array_type
14811         = build_java_array_type (type,
14812                                  TREE_CODE (cdim) == INTEGER_CST
14813                                  ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
14814                                  : -1);
14815       array_type = promote_type (array_type);
14816     }
14817   dims = nreverse (dims);
14818
14819   /* The node is transformed into a function call. Things are done
14820      differently according to the number of dimensions. If the number
14821      of dimension is equal to 1, then the nature of the base type
14822      (primitive or not) matters. */
14823   if (ndims == 1)
14824     return build_new_array (type, TREE_VALUE (dims));
14825
14826   /* Can't reuse what's already written in expr.c because it uses the
14827      JVM stack representation. Provide a build_multianewarray. FIXME */
14828   return build3 (CALL_EXPR, array_type,
14829                  build_address_of (soft_multianewarray_node),
14830                  tree_cons (NULL_TREE,
14831                             build_class_ref (TREE_TYPE (array_type)),
14832                             tree_cons (NULL_TREE,
14833                                        build_int_cst (NULL_TREE, ndims),
14834                                        dims)),
14835                  NULL_TREE);
14836 }
14837
14838 /* 10.6 Array initializer.  */
14839
14840 /* Build a wfl for array element that don't have one, so we can
14841    pin-point errors.  */
14842
14843 static tree
14844 maybe_build_array_element_wfl (tree node)
14845 {
14846   if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
14847     {
14848       /* FIXME - old code used "prev_lc.line" and "elc.prev_col */
14849       return build_expr_wfl (NULL_TREE,
14850 #ifdef USE_MAPPED_LOCATION
14851                              input_location
14852 #else
14853                              ctxp->filename,
14854                              ctxp->lexer->token_start.line,
14855                              ctxp->lexer->token_start.col
14856 #endif
14857                              );
14858     }
14859   else
14860     return NULL_TREE;
14861 }
14862
14863 /* Build a NEW_ARRAY_INIT that features a CONSTRUCTOR node. This makes
14864    identification of initialized arrays easier to detect during walk
14865    and expansion.  */
14866
14867 static tree
14868 build_new_array_init (int location, tree values)
14869 {
14870   tree constructor = build_constructor_from_list (NULL_TREE,
14871                                                   nreverse (values));
14872   tree to_return = build1 (NEW_ARRAY_INIT, NULL_TREE, constructor);
14873   EXPR_WFL_LINECOL (to_return) = location;
14874   return to_return;
14875 }
14876
14877 /* Expand a NEW_ARRAY_INIT node. Return error_mark_node if an error
14878    occurred.  Otherwise return NODE after having set its type
14879    appropriately.  */
14880
14881 static tree
14882 patch_new_array_init (tree type, tree node)
14883 {
14884   int error_seen = 0;
14885   tree element_type;
14886   unsigned HOST_WIDE_INT length;
14887   constructor_elt *current;
14888   int all_constant = 1;
14889   tree init = TREE_OPERAND (node, 0);
14890
14891   if (TREE_CODE (type) != POINTER_TYPE || ! TYPE_ARRAY_P (TREE_TYPE (type)))
14892     {
14893       parse_error_context (node,
14894                            "Invalid array initializer for non-array type %qs",
14895                            lang_printable_name (type, 1));
14896       return error_mark_node;
14897     }
14898   type = TREE_TYPE (type);
14899   element_type = TYPE_ARRAY_ELEMENT (type);
14900
14901   for (length = 0;
14902        VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init),
14903                     length, current);
14904        length++)
14905     {
14906       tree elt = current->value;
14907       if (elt == NULL_TREE || TREE_CODE (elt) != NEW_ARRAY_INIT)
14908         {
14909           error_seen |= array_constructor_check_entry (element_type, current);
14910           elt = current->value;
14911           /* When compiling to native code, STRING_CST is converted to
14912              INDIRECT_REF, but still with a TREE_CONSTANT flag. */
14913           if (! TREE_CONSTANT (elt) || TREE_CODE (elt) == INDIRECT_REF)
14914             all_constant = 0;
14915         }
14916       else
14917         {
14918           current->value = patch_new_array_init (element_type, elt);
14919           current->index = NULL_TREE;
14920           all_constant = 0;
14921         }
14922       if (elt && TREE_CODE (elt) == TREE_LIST
14923           && TREE_VALUE (elt) == error_mark_node)
14924         error_seen = 1;
14925     }
14926
14927   if (error_seen)
14928     return error_mark_node;
14929
14930   /* Create a new type. We can't reuse the one we have here by
14931      patching its dimension because it originally is of dimension -1
14932      hence reused by gcc. This would prevent triangular arrays. */
14933   type = build_java_array_type (element_type, length);
14934   TREE_TYPE (init) = TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (type))));
14935   TREE_TYPE (node) = promote_type (type);
14936   TREE_CONSTANT (init) = all_constant;
14937   TREE_INVARIANT (init) = all_constant;
14938   TREE_CONSTANT (node) = all_constant;
14939   TREE_INVARIANT (node) = all_constant;
14940   return node;
14941 }
14942
14943 /* Verify that one entry of the initializer element list can be
14944    assigned to the array base type. Report 1 if an error occurred, 0
14945    otherwise.  */
14946
14947 static int
14948 array_constructor_check_entry (tree type, constructor_elt *entry)
14949 {
14950   char *array_type_string = NULL;       /* For error reports */
14951   tree value, type_value, new_value, wfl_value, patched;
14952   int error_seen = 0;
14953
14954   new_value = NULL_TREE;
14955   wfl_value = entry->value;
14956
14957   value = java_complete_tree (entry->value);
14958   /* patch_string return error_mark_node if arg is error_mark_node */
14959   if ((patched = patch_string (value)))
14960     value = patched;
14961   if (value == error_mark_node)
14962     return 1;
14963
14964   type_value = TREE_TYPE (value);
14965
14966   /* At anytime, try_builtin_assignconv can report a warning on
14967      constant overflow during narrowing. */
14968   SET_WFL_OPERATOR (wfl_operator, entry->index, wfl_value);
14969   new_value = try_builtin_assignconv (wfl_operator, type, value);
14970   if (!new_value && (new_value = try_reference_assignconv (type, value)))
14971     type_value = promote_type (type);
14972
14973   /* Check and report errors */
14974   if (!new_value)
14975     {
14976       const char *const msg = (!valid_cast_to_p (type_value, type) ?
14977                    "Can't" : "Explicit cast needed to");
14978       if (!array_type_string)
14979         array_type_string = xstrdup (lang_printable_name (type, 1));
14980       parse_error_context
14981         (wfl_operator, "Incompatible type for array. %s convert %qs to %qs",
14982          msg, lang_printable_name (type_value, 1), array_type_string);
14983       error_seen = 1;
14984     }
14985
14986   if (new_value)
14987     entry->value = new_value;
14988
14989   if (array_type_string)
14990     free (array_type_string);
14991
14992   entry->index = NULL_TREE;
14993   return error_seen;
14994 }
14995
14996 static tree
14997 build_this (int location)
14998 {
14999   tree node = build_wfl_node (this_identifier_node);
15000   TREE_SET_CODE (node, THIS_EXPR);
15001   EXPR_WFL_LINECOL (node) = location;
15002   return node;
15003 }
15004
15005 /* 14.15 The return statement. It builds a modify expression that
15006    assigns the returned value to the RESULT_DECL that hold the value
15007    to be returned. */
15008
15009 static tree
15010 build_return (int location, tree op)
15011 {
15012   tree node = build1 (RETURN_EXPR, NULL_TREE, op);
15013   EXPR_WFL_LINECOL (node) = location;
15014   node = build_debugable_stmt (location, node);
15015   return node;
15016 }
15017
15018 static tree
15019 patch_return (tree node)
15020 {
15021   tree return_exp = TREE_OPERAND (node, 0);
15022   tree meth = current_function_decl;
15023   tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
15024   int error_found = 0;
15025
15026   TREE_TYPE (node) = error_mark_node;
15027   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15028
15029   /* It's invalid to have a return value within a function that is
15030      declared with the keyword void or that is a constructor */
15031   if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
15032     error_found = 1;
15033
15034   /* It's invalid to use a return statement in a static block */
15035   if (DECL_CLINIT_P (current_function_decl))
15036     error_found = 1;
15037
15038   /* It's invalid to have a no return value within a function that
15039      isn't declared with the keyword `void' */
15040   if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
15041     error_found = 2;
15042
15043   if (DECL_INSTINIT_P (current_function_decl))
15044     error_found = 1;
15045
15046   if (error_found)
15047     {
15048       if (DECL_INSTINIT_P (current_function_decl))
15049         parse_error_context (wfl_operator,
15050                              "%<return%> inside instance initializer");
15051
15052       else if (DECL_CLINIT_P (current_function_decl))
15053         parse_error_context (wfl_operator,
15054                              "%<return%> inside static initializer");
15055
15056       else if (!DECL_CONSTRUCTOR_P (meth))
15057         {
15058           char *t = xstrdup (lang_printable_name (mtype, 0));
15059           parse_error_context (wfl_operator,
15060                                "%<return%> with%s value from %<%s %s%>",
15061                                (error_found == 1 ? "" : "out"),
15062                                t, lang_printable_name (meth, 2));
15063           free (t);
15064         }
15065       else
15066         parse_error_context (wfl_operator,
15067                              "%<return%> with value from constructor %qs",
15068                              lang_printable_name (meth, 2));
15069       return error_mark_node;
15070     }
15071
15072   /* If we have a return_exp, build a modify expression and expand
15073      it. Note: at that point, the assignment is declared valid, but we
15074      may want to carry some more hacks */
15075   if (return_exp)
15076     {
15077       tree exp = java_complete_tree (return_exp);
15078       tree modify, patched;
15079
15080       if ((patched = patch_string (exp)))
15081         exp = patched;
15082
15083       modify = build2 (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), exp);
15084       EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
15085       modify = java_complete_tree (modify);
15086
15087       if (modify != error_mark_node)
15088         {
15089           TREE_SIDE_EFFECTS (modify) = 1;
15090           TREE_OPERAND (node, 0) = modify;
15091         }
15092       else
15093         return error_mark_node;
15094     }
15095   TREE_TYPE (node) = void_type_node;
15096   TREE_SIDE_EFFECTS (node) = 1;
15097   return node;
15098 }
15099
15100 /* 14.8 The if Statement */
15101
15102 static tree
15103 build_if_else_statement (int location, tree expression, tree if_body,
15104                          tree else_body)
15105 {
15106   tree node;
15107   if (!else_body)
15108     else_body = build_java_empty_stmt ();
15109   node = build3 (COND_EXPR, NULL_TREE, expression, if_body, else_body);
15110   EXPR_WFL_LINECOL (node) = location;
15111   node = build_debugable_stmt (location, node);
15112   return node;
15113 }
15114
15115 static tree
15116 patch_if_else_statement (tree node)
15117 {
15118   tree expression = TREE_OPERAND (node, 0);
15119   int can_complete_normally
15120     = (CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15121        | CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 2)));
15122
15123   TREE_TYPE (node) = error_mark_node;
15124   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15125
15126   /* The type of expression must be boolean */
15127   if (TREE_TYPE (expression) != boolean_type_node
15128       && TREE_TYPE (expression) != promoted_boolean_type_node)
15129     {
15130       parse_error_context
15131         (wfl_operator,
15132          "Incompatible type for %<if%>. Can't convert %qs to %<boolean%>",
15133          lang_printable_name (TREE_TYPE (expression), 0));
15134       return error_mark_node;
15135     }
15136
15137   TREE_TYPE (node) = void_type_node;
15138   TREE_SIDE_EFFECTS (node) = 1;
15139   CAN_COMPLETE_NORMALLY (node) = can_complete_normally;
15140   return node;
15141 }
15142
15143 /* 14.6 Labeled Statements */
15144
15145 /* Action taken when a labeled statement is parsed. a new
15146    LABELED_BLOCK_EXPR is created. No statement is attached to the
15147    label, yet.  LABEL can be NULL_TREE for artificially-generated blocks. */
15148
15149 static tree
15150 build_labeled_block (int location, tree label)
15151 {
15152   tree label_name ;
15153   tree label_decl, node;
15154   if (label == NULL_TREE || label == continue_identifier_node)
15155     label_name = label;
15156   else
15157     {
15158       label_name = merge_qualified_name (label_id, label);
15159       /* Issue an error if we try to reuse a label that was previously
15160          declared */
15161       if (IDENTIFIER_LOCAL_VALUE (label_name))
15162         {
15163           EXPR_WFL_LINECOL (wfl_operator) = location;
15164           parse_error_context (wfl_operator,
15165             "Declaration of %qs shadows a previous label declaration",
15166                                IDENTIFIER_POINTER (label));
15167           EXPR_WFL_LINECOL (wfl_operator) =
15168             EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
15169           parse_error_context (wfl_operator,
15170             "This is the location of the previous declaration of label %qs",
15171                                IDENTIFIER_POINTER (label));
15172           java_error_count--;
15173         }
15174     }
15175
15176   label_decl = create_label_decl (label_name);
15177   node = build2 (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
15178   EXPR_WFL_LINECOL (node) = location;
15179   TREE_SIDE_EFFECTS (node) = 1;
15180   return node;
15181 }
15182
15183 /* A labeled statement LBE is attached a statement.  */
15184
15185 static tree
15186 finish_labeled_statement (tree lbe, /* Labeled block expr */
15187                           tree statement)
15188 {
15189   /* In anyways, tie the loop to its statement */
15190   LABELED_BLOCK_BODY (lbe) = statement;
15191   pop_labeled_block ();
15192   POP_LABELED_BLOCK ();
15193   return lbe;
15194 }
15195
15196 /* 14.10, 14.11, 14.12 Loop Statements */
15197
15198 /* Create an empty LOOP_EXPR and make it the last in the nested loop
15199    list. */
15200
15201 static tree
15202 build_new_loop (tree loop_body)
15203 {
15204   tree loop = build1 (LOOP_EXPR, NULL_TREE, loop_body);
15205   TREE_SIDE_EFFECTS (loop) = 1;
15206   PUSH_LOOP (loop);
15207   return loop;
15208 }
15209
15210 /* Create a loop body according to the following structure:
15211      COMPOUND_EXPR
15212        COMPOUND_EXPR            (loop main body)
15213          EXIT_EXPR              (this order is for while/for loops.
15214          LABELED_BLOCK_EXPR      the order is reversed for do loops)
15215            LABEL_DECL           (a continue occurring here branches at the
15216            BODY                  end of this labeled block)
15217        INCREMENT                (if any)
15218
15219   REVERSED, if nonzero, tells that the loop condition expr comes
15220   after the body, like in the do-while loop.
15221
15222   To obtain a loop, the loop body structure described above is
15223   encapsulated within a LOOP_EXPR surrounded by a LABELED_BLOCK_EXPR:
15224
15225    LABELED_BLOCK_EXPR
15226      LABEL_DECL                   (use this label to exit the loop)
15227      LOOP_EXPR
15228        <structure described above> */
15229
15230 static tree
15231 build_loop_body (int location, tree condition, int reversed)
15232 {
15233   tree first, second, body;
15234
15235   condition = build1 (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
15236   EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
15237   condition = build_debugable_stmt (location, condition);
15238   TREE_SIDE_EFFECTS (condition) = 1;
15239
15240   body = build_labeled_block (0, continue_identifier_node);
15241   first = (reversed ? body : condition);
15242   second = (reversed ? condition : body);
15243   return build2 (COMPOUND_EXPR, NULL_TREE,
15244                  build2 (COMPOUND_EXPR, NULL_TREE, first, second),
15245                  build_java_empty_stmt ());
15246 }
15247
15248 /* Install CONDITION (if any) and loop BODY (using REVERSED to tell
15249    their order) on the current loop. Unlink the current loop from the
15250    loop list.  */
15251
15252 static tree
15253 finish_loop_body (int location, tree condition, tree body, int reversed)
15254 {
15255   tree to_return = ctxp->current_loop;
15256   tree loop_body = LOOP_EXPR_BODY (to_return);
15257   if (condition)
15258     {
15259       tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
15260       /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
15261          The real EXIT_EXPR is one operand further. */
15262       EXPR_WFL_LINECOL (cnode) = location;
15263       if (TREE_CODE (cnode) == EXPR_WITH_FILE_LOCATION)
15264         {
15265           cnode = EXPR_WFL_NODE (cnode);
15266           /* This one is for accurate error reports */
15267           EXPR_WFL_LINECOL (cnode) = location;
15268         }
15269       TREE_OPERAND (cnode, 0) = condition;
15270     }
15271   LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
15272   POP_LOOP ();
15273   return to_return;
15274 }
15275
15276 /* Tailored version of finish_loop_body for FOR loops, when FOR
15277    loops feature the condition part */
15278
15279 static tree
15280 finish_for_loop (int location, tree condition, tree update, tree body)
15281 {
15282   /* Put the condition and the loop body in place */
15283   tree loop = finish_loop_body (location, condition, body, 0);
15284   /* LOOP is the current loop which has been now popped of the loop
15285      stack.  Mark the update block as reachable and install it.  We do
15286      this because the (current interpretation of the) JLS requires
15287      that the update expression be considered reachable even if the
15288      for loop's body doesn't complete normally.  */
15289   if (update != NULL_TREE && !IS_EMPTY_STMT (update))
15290     {
15291       tree up2 = update;
15292       if (TREE_CODE (up2) == EXPR_WITH_FILE_LOCATION)
15293         up2 = EXPR_WFL_NODE (up2);
15294       /* It is possible for the update expression to be an
15295          EXPR_WFL_NODE wrapping nothing.  */
15296       if (up2 != NULL_TREE && !IS_EMPTY_STMT (up2))
15297         {
15298           /* Try to detect constraint violations.  These would be
15299              programming errors somewhere.  */
15300           if (! EXPR_P (up2) || TREE_CODE (up2) == LOOP_EXPR)
15301             abort ();
15302           SUPPRESS_UNREACHABLE_ERROR (up2) = 1;
15303         }
15304     }
15305   LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
15306   return loop;
15307 }
15308
15309 /* Try to find the loop a block might be related to. This comprises
15310    the case where the LOOP_EXPR is found as the second operand of a
15311    COMPOUND_EXPR, because the loop happens to have an initialization
15312    part, then expressed as the first operand of the COMPOUND_EXPR. If
15313    the search finds something, 1 is returned. Otherwise, 0 is
15314    returned. The search is assumed to start from a
15315    LABELED_BLOCK_EXPR's block.  */
15316
15317 static tree
15318 search_loop (tree statement)
15319 {
15320   if (TREE_CODE (statement) == LOOP_EXPR)
15321     return statement;
15322
15323   if (TREE_CODE (statement) == BLOCK)
15324     statement = BLOCK_SUBBLOCKS (statement);
15325   else
15326     return NULL_TREE;
15327
15328   if (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15329     while (statement && TREE_CODE (statement) == COMPOUND_EXPR)
15330       statement = TREE_OPERAND (statement, 1);
15331
15332   return (TREE_CODE (statement) == LOOP_EXPR
15333           && FOR_LOOP_P (statement) ? statement : NULL_TREE);
15334 }
15335
15336 /* Return 1 if LOOP can be found in the labeled block BLOCK. 0 is
15337    returned otherwise.  */
15338
15339 static int
15340 labeled_block_contains_loop_p (tree block, tree loop)
15341 {
15342   if (!block)
15343     return 0;
15344
15345   if (LABELED_BLOCK_BODY (block) == loop)
15346     return 1;
15347
15348   if (FOR_LOOP_P (loop) && search_loop (LABELED_BLOCK_BODY (block)) == loop)
15349     return 1;
15350
15351   return 0;
15352 }
15353
15354 /* If the loop isn't surrounded by a labeled statement, create one and
15355    insert LOOP as its body.  */
15356
15357 static tree
15358 patch_loop_statement (tree loop)
15359 {
15360   tree loop_label;
15361
15362   TREE_TYPE (loop) = void_type_node;
15363   if (labeled_block_contains_loop_p (ctxp->current_labeled_block, loop))
15364     return loop;
15365
15366   loop_label = build_labeled_block (0, NULL_TREE);
15367   /* LOOP is an EXPR node, so it should have a valid EXPR_WFL_LINECOL
15368      that LOOP_LABEL could enquire about, for a better accuracy. FIXME */
15369   LABELED_BLOCK_BODY (loop_label) = loop;
15370   PUSH_LABELED_BLOCK (loop_label);
15371   return loop_label;
15372 }
15373
15374 /* 14.13, 14.14: break and continue Statements */
15375
15376 /* Build a break or a continue statement. a null NAME indicates an
15377    unlabeled break/continue statement.  */
15378
15379 static tree
15380 build_bc_statement (int location, int is_break, tree name)
15381 {
15382   tree break_continue, label_block_expr = NULL_TREE;
15383
15384   if (name)
15385     {
15386       if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
15387             (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
15388         /* Null means that we don't have a target for this named
15389            break/continue. In this case, we make the target to be the
15390            label name, so that the error can be reported accurately in
15391            patch_bc_statement. */
15392         label_block_expr = EXPR_WFL_NODE (name);
15393     }
15394   /* Unlabeled break/continue will be handled during the
15395      break/continue patch operation */
15396   break_continue = build1 (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr);
15397
15398   IS_BREAK_STMT_P (break_continue) = is_break;
15399   TREE_SIDE_EFFECTS (break_continue) = 1;
15400   EXPR_WFL_LINECOL (break_continue) = location;
15401   break_continue = build_debugable_stmt (location, break_continue);
15402   return break_continue;
15403 }
15404
15405 /* Verification of a break/continue statement. */
15406
15407 static tree
15408 patch_bc_statement (tree node)
15409 {
15410   tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
15411   tree labeled_block = ctxp->current_labeled_block;
15412   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15413
15414   /* Having an identifier here means that the target is unknown. */
15415   if (bc_label != NULL_TREE && TREE_CODE (bc_label) == IDENTIFIER_NODE)
15416     {
15417       parse_error_context (wfl_operator, "No label definition found for %qs",
15418                            IDENTIFIER_POINTER (bc_label));
15419       return error_mark_node;
15420     }
15421   if (! IS_BREAK_STMT_P (node))
15422     {
15423       /* It's a continue statement. */
15424       for (;; labeled_block = TREE_CHAIN (labeled_block))
15425         {
15426           if (labeled_block == NULL_TREE)
15427             {
15428               if (bc_label == NULL_TREE)
15429                 parse_error_context (wfl_operator,
15430                                      "%<continue%> must be in loop");
15431               else
15432                 parse_error_context
15433                   (wfl_operator, "continue label %qs does not name a loop",
15434                    IDENTIFIER_POINTER (bc_label));
15435               return error_mark_node;
15436             }
15437           if ((DECL_NAME (LABELED_BLOCK_LABEL (labeled_block))
15438                == continue_identifier_node)
15439               && (bc_label == NULL_TREE
15440                   || TREE_CHAIN (labeled_block) == bc_label))
15441             {
15442               bc_label = labeled_block;
15443               break;
15444             }
15445         }
15446     }
15447   else if (!bc_label)
15448     {
15449       for (;; labeled_block = TREE_CHAIN (labeled_block))
15450         {
15451           if (labeled_block == NULL_TREE)
15452             {
15453               parse_error_context (wfl_operator,
15454                                      "%<break%> must be in loop or switch");
15455               return error_mark_node;
15456             }
15457           target_stmt = LABELED_BLOCK_BODY (labeled_block);
15458           if (TREE_CODE (target_stmt) == SWITCH_EXPR
15459               || search_loop (target_stmt))
15460             {
15461               bc_label = labeled_block;
15462               break;
15463             }
15464         }
15465     }
15466
15467   EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
15468   CAN_COMPLETE_NORMALLY (bc_label) = 1;
15469
15470   /* Our break/continue don't return values. */
15471   TREE_TYPE (node) = void_type_node;
15472   /* Encapsulate the break within a compound statement so that it's
15473      expanded all the times by expand_expr (and not clobbered
15474      sometimes, like after a if statement) */
15475   node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
15476   TREE_SIDE_EFFECTS (node) = 1;
15477   return node;
15478 }
15479
15480 /* Process the exit expression belonging to a loop. Its type must be
15481    boolean.  */
15482
15483 static tree
15484 patch_exit_expr (tree node)
15485 {
15486   tree expression = TREE_OPERAND (node, 0);
15487   TREE_TYPE (node) = error_mark_node;
15488   EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15489
15490   /* The type of expression must be boolean */
15491   if (TREE_TYPE (expression) != boolean_type_node)
15492     {
15493       parse_error_context
15494         (wfl_operator,
15495     "Incompatible type for loop conditional. Can't convert %qs to %<boolean%>",
15496          lang_printable_name (TREE_TYPE (expression), 0));
15497       return error_mark_node;
15498     }
15499   /* Now we know things are allright, invert the condition, fold and
15500      return */
15501   TREE_OPERAND (node, 0) =
15502     fold_build1 (TRUTH_NOT_EXPR, boolean_type_node, expression);
15503
15504   if (! integer_zerop (TREE_OPERAND (node, 0))
15505       && ctxp->current_loop != NULL_TREE
15506       && TREE_CODE (ctxp->current_loop) == LOOP_EXPR)
15507     CAN_COMPLETE_NORMALLY (ctxp->current_loop) = 1;
15508   if (! integer_onep (TREE_OPERAND (node, 0)))
15509     CAN_COMPLETE_NORMALLY (node) = 1;
15510
15511
15512   TREE_TYPE (node) = void_type_node;
15513   return node;
15514 }
15515
15516 /* 14.9 Switch statement */
15517
15518 static tree
15519 patch_switch_statement (tree node)
15520 {
15521   tree se = TREE_OPERAND (node, 0), se_type;
15522   tree save, iter;
15523
15524   /* Complete the switch expression */
15525   se = TREE_OPERAND (node, 0) = java_complete_tree (se);
15526   se_type = TREE_TYPE (se);
15527   /* The type of the switch expression must be char, byte, short or
15528      int */
15529   if (! JINTEGRAL_TYPE_P (se_type) || se_type == long_type_node)
15530     {
15531       EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
15532       parse_error_context (wfl_operator,
15533           "Incompatible type for %<switch%>. Can't convert %qs to %<int%>",
15534                            lang_printable_name (se_type, 0));
15535       /* This is what java_complete_tree will check */
15536       TREE_OPERAND (node, 0) = error_mark_node;
15537       return error_mark_node;
15538     }
15539
15540   /* Save and restore the outer case label list.  */
15541   save = case_label_list;
15542   case_label_list = NULL_TREE;
15543
15544   TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
15545
15546   /* See if we've found a duplicate label.  We can't leave this until
15547      code generation, because in `--syntax-only' and `-C' modes we
15548      don't do ordinary code generation.  */
15549   for (iter = case_label_list; iter != NULL_TREE; iter = TREE_CHAIN (iter))
15550     {
15551       HOST_WIDE_INT val = TREE_INT_CST_LOW (TREE_VALUE (iter));
15552       tree subiter;
15553       for (subiter = TREE_CHAIN (iter);
15554            subiter != NULL_TREE;
15555            subiter = TREE_CHAIN (subiter))
15556         {
15557           HOST_WIDE_INT subval = TREE_INT_CST_LOW (TREE_VALUE (subiter));
15558           if (val == subval)
15559             {
15560               EXPR_WFL_LINECOL (wfl_operator)
15561                 = EXPR_WFL_LINECOL (TREE_PURPOSE (iter));
15562               /* The case_label_list is in reverse order, so print the
15563                  outer label first.  */
15564               parse_error_context (wfl_operator, "duplicate case label: %<"
15565                                    HOST_WIDE_INT_PRINT_DEC "%>", subval);
15566               EXPR_WFL_LINECOL (wfl_operator)
15567                 = EXPR_WFL_LINECOL (TREE_PURPOSE (subiter));
15568               parse_error_context (wfl_operator, "original label is here");
15569
15570               break;
15571             }
15572         }
15573     }
15574
15575   case_label_list = save;
15576
15577   /* Ready to return */
15578   if (TREE_CODE (TREE_OPERAND (node, 1)) == ERROR_MARK)
15579     {
15580       TREE_TYPE (node) = error_mark_node;
15581       return error_mark_node;
15582     }
15583   TREE_TYPE (node) = void_type_node;
15584   TREE_SIDE_EFFECTS (node) = 1;
15585   CAN_COMPLETE_NORMALLY (node)
15586     = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1))
15587       || ! SWITCH_HAS_DEFAULT (node);
15588   return node;
15589 }
15590
15591 /* Assertions.  */
15592
15593 /* Build an assertion expression for `assert CONDITION : VALUE'; VALUE
15594    might be NULL_TREE.  */
15595 static tree
15596 build_assertion (
15597 #ifdef USE_MAPPED_LOCATION
15598                  source_location location,
15599 #else
15600                  int location,
15601 #endif
15602                  tree condition, tree value)
15603 {
15604   tree node;
15605   tree klass = GET_CPC ();
15606
15607   if (! enable_assertions (klass))
15608     {
15609       condition = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15610                           boolean_false_node, condition);
15611       if (value == NULL_TREE)
15612         value = build_java_empty_stmt ();
15613       return build_if_else_statement (location, condition,
15614                                       value, NULL_TREE);
15615     }
15616
15617   if (! CLASS_USES_ASSERTIONS (klass))
15618     {
15619       tree field, classdollar, id, call;
15620       tree class_type = TREE_TYPE (klass);
15621
15622       field = add_field (class_type,
15623                          get_identifier ("$assertionsDisabled"),
15624                          boolean_type_node,
15625                          ACC_PRIVATE | ACC_STATIC | ACC_FINAL);
15626       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (field);
15627       FIELD_SYNTHETIC (field) = 1;
15628
15629       classdollar = build_incomplete_class_ref (location, class_type);
15630
15631       /* Call CLASS.desiredAssertionStatus().  */
15632       id = build_wfl_node (get_identifier ("desiredAssertionStatus"));
15633       call = build3 (CALL_EXPR, NULL_TREE, id, NULL_TREE, NULL_TREE);
15634       call = make_qualified_primary (classdollar, call, location);
15635       TREE_SIDE_EFFECTS (call) = 1;
15636
15637       /* Invert to obtain !CLASS.desiredAssertionStatus().  This may
15638          seem odd, but we do it to generate code identical to that of
15639          the JDK.  */
15640       call = build1 (TRUTH_NOT_EXPR, NULL_TREE, call);
15641       TREE_SIDE_EFFECTS (call) = 1;
15642       DECL_INITIAL (field) = call;
15643
15644       /* Record the initializer in the initializer statement list.  */
15645       call = build2 (MODIFY_EXPR, NULL_TREE, field, call);
15646       TREE_CHAIN (call) = CPC_STATIC_INITIALIZER_STMT (ctxp);
15647       SET_CPC_STATIC_INITIALIZER_STMT (ctxp, call);
15648       MODIFY_EXPR_FROM_INITIALIZATION_P (call) = 1;
15649
15650       CLASS_USES_ASSERTIONS (klass) = 1;
15651     }
15652
15653   if (value != NULL_TREE)
15654     value = tree_cons (NULL_TREE, value, NULL_TREE);
15655
15656   node = build_wfl_node (get_identifier ("java"));
15657   node = make_qualified_name (node, build_wfl_node (get_identifier ("lang")),
15658                               location);
15659   node = make_qualified_name (node, build_wfl_node (get_identifier ("AssertionError")),
15660                               location);
15661
15662   node = build3 (NEW_CLASS_EXPR, NULL_TREE, node, value, NULL_TREE);
15663   TREE_SIDE_EFFECTS (node) = 1;
15664   /* It is too early to use BUILD_THROW.  */
15665   node = build1 (THROW_EXPR, NULL_TREE, node);
15666   TREE_SIDE_EFFECTS (node) = 1;
15667
15668   /* We invert the condition; if we just put NODE as the `else' part
15669      then we generate weird-looking bytecode.  */
15670   condition = build1 (TRUTH_NOT_EXPR, NULL_TREE, condition);
15671   /* Check $assertionsDisabled.  */
15672   condition
15673     = build2 (TRUTH_ANDIF_EXPR, NULL_TREE,
15674               build1 (TRUTH_NOT_EXPR, NULL_TREE,
15675                       build_wfl_node (get_identifier ("$assertionsDisabled"))),
15676               condition);
15677   node = build_if_else_statement (location, condition, node, NULL_TREE);
15678   return node;
15679 }
15680
15681 /* 14.18 The try/catch statements */
15682
15683 /* Encapsulate TRY_STMTS' in a try catch sequence. The catch clause
15684    catches TYPE and executes CATCH_STMTS.  */
15685
15686 static tree
15687 encapsulate_with_try_catch (int location, tree type_or_name, tree try_stmts,
15688                             tree catch_stmts)
15689 {
15690   tree try_block, catch_clause_param, catch_block, catch;
15691
15692   /* First build a try block */
15693   try_block = build_expr_block (try_stmts, NULL_TREE);
15694
15695   /* Build a catch block: we need a catch clause parameter */
15696   if (TREE_CODE (type_or_name) == EXPR_WITH_FILE_LOCATION)
15697     {
15698       tree catch_type = obtain_incomplete_type (type_or_name);
15699       jdep *dep;
15700       catch_clause_param = build_decl (VAR_DECL, wpv_id, catch_type);
15701       register_incomplete_type (JDEP_VARIABLE, type_or_name,
15702                                 catch_clause_param, catch_type);
15703       dep = CLASSD_LAST (ctxp->classd_list);
15704       JDEP_GET_PATCH (dep) = &TREE_TYPE (catch_clause_param);
15705     }
15706   else
15707     catch_clause_param = build_decl (VAR_DECL, wpv_id,
15708                                      build_pointer_type (type_or_name));
15709
15710   /* And a block */
15711   catch_block = build_expr_block (NULL_TREE, catch_clause_param);
15712
15713   /* Initialize the variable and store in the block */
15714   catch = build2 (MODIFY_EXPR, NULL_TREE, catch_clause_param,
15715                   build0 (JAVA_EXC_OBJ_EXPR, ptr_type_node));
15716   add_stmt_to_block (catch_block, NULL_TREE, catch);
15717
15718   /* Add the catch statements */
15719   add_stmt_to_block (catch_block, NULL_TREE, catch_stmts);
15720
15721   /* Now we can build a JAVA_CATCH_EXPR */
15722   catch_block = build1 (JAVA_CATCH_EXPR, NULL_TREE, catch_block);
15723
15724   return build_try_statement (location, try_block, catch_block);
15725 }
15726
15727 static tree
15728 build_try_statement (int location, tree try_block, tree catches)
15729 {
15730   tree node = build2 (TRY_EXPR, NULL_TREE, try_block, catches);
15731   EXPR_WFL_LINECOL (node) = location;
15732   return node;
15733 }
15734
15735 static tree
15736 build_try_finally_statement (int location, tree try_block, tree finally)
15737 {
15738   tree node = build2 (TRY_FINALLY_EXPR, NULL_TREE, try_block, finally);
15739   EXPR_WFL_LINECOL (node) = location;
15740   return node;
15741 }
15742
15743 static tree
15744 patch_try_statement (tree node)
15745 {
15746   int error_found = 0;
15747   tree try = TREE_OPERAND (node, 0);
15748   /* Exception handlers are considered in left to right order */
15749   tree catch = nreverse (TREE_OPERAND (node, 1));
15750   tree current, caught_type_list = NULL_TREE;
15751
15752   /* Check catch clauses, if any. Every time we find an error, we try
15753      to process the next catch clause. We process the catch clause before
15754      the try block so that when processing the try block we can check thrown
15755      exceptions against the caught type list. */
15756   for (current = catch; current; current = TREE_CHAIN (current))
15757     {
15758       tree carg_decl, carg_type;
15759       tree sub_current, catch_block, catch_clause;
15760       int unreachable;
15761
15762       /* At this point, the structure of the catch clause is
15763            JAVA_CATCH_EXPR              (catch node)
15764              BLOCK              (with the decl of the parameter)
15765                COMPOUND_EXPR
15766                  MODIFY_EXPR   (assignment of the catch parameter)
15767                  BLOCK          (catch clause block)
15768        */
15769       catch_clause = TREE_OPERAND (current, 0);
15770       carg_decl = BLOCK_EXPR_DECLS (catch_clause);
15771       carg_type = TREE_TYPE (TREE_TYPE (carg_decl));
15772
15773       /* Catch clauses can't have more than one parameter declared,
15774          but it's already enforced by the grammar. Make sure that the
15775          only parameter of the clause statement in of class Throwable
15776          or a subclass of Throwable, but that was done earlier. The
15777          catch clause parameter type has also been resolved. */
15778
15779       /* Just make sure that the catch clause parameter type inherits
15780          from java.lang.Throwable */
15781       if (!inherits_from_p (carg_type, throwable_type_node))
15782         {
15783           EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15784           parse_error_context (wfl_operator,
15785                                "Can't catch class %qs. Catch clause parameter type must be a subclass of class %<java.lang.Throwable%>",
15786                                lang_printable_name (carg_type, 0));
15787           error_found = 1;
15788           continue;
15789         }
15790
15791       /* Partial check for unreachable catch statement: The catch
15792          clause is reachable iff is no earlier catch block A in
15793          the try statement such that the type of the catch
15794          clause's parameter is the same as or a subclass of the
15795          type of A's parameter */
15796       unreachable = 0;
15797       for (sub_current = catch;
15798            sub_current != current; sub_current = TREE_CHAIN (sub_current))
15799         {
15800           tree sub_catch_clause, decl;
15801           sub_catch_clause = TREE_OPERAND (sub_current, 0);
15802           decl = BLOCK_EXPR_DECLS (sub_catch_clause);
15803
15804           if (inherits_from_p (carg_type, TREE_TYPE (TREE_TYPE (decl))))
15805             {
15806               EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (current);
15807               parse_error_context
15808                 (wfl_operator,
15809                  "%<catch%> not reached because of the catch clause at line %d",
15810                  EXPR_WFL_LINENO (sub_current));
15811               unreachable = error_found = 1;
15812               break;
15813             }
15814         }
15815       /* Complete the catch clause block */
15816       catch_block = java_complete_tree (TREE_OPERAND (current, 0));
15817       if (catch_block == error_mark_node)
15818         {
15819           error_found = 1;
15820           continue;
15821         }
15822       if (CAN_COMPLETE_NORMALLY (catch_block))
15823         CAN_COMPLETE_NORMALLY (node) = 1;
15824       TREE_OPERAND (current, 0) = catch_block;
15825
15826       if (unreachable)
15827         continue;
15828
15829       /* Things to do here: the exception must be thrown */
15830
15831       /* Link this type to the caught type list */
15832       caught_type_list = tree_cons (NULL_TREE, carg_type, caught_type_list);
15833     }
15834
15835   PUSH_EXCEPTIONS (caught_type_list);
15836   if ((try = java_complete_tree (try)) == error_mark_node)
15837     error_found = 1;
15838   if (CAN_COMPLETE_NORMALLY (try))
15839     CAN_COMPLETE_NORMALLY (node) = 1;
15840   POP_EXCEPTIONS ();
15841
15842   /* Verification ends here */
15843   if (error_found)
15844     return error_mark_node;
15845
15846   TREE_OPERAND (node, 0) = try;
15847   TREE_OPERAND (node, 1) = catch;
15848   TREE_TYPE (node) = void_type_node;
15849   return node;
15850 }
15851
15852 /* 14.17 The synchronized Statement */
15853
15854 static tree
15855 patch_synchronized_statement (tree node, tree wfl_op1)
15856 {
15857   tree expr = java_complete_tree (TREE_OPERAND (node, 0));
15858   tree block = TREE_OPERAND (node, 1);
15859
15860   tree tmp, enter, exit, expr_decl, assignment;
15861
15862   if (expr == error_mark_node)
15863     {
15864       block = java_complete_tree (block);
15865       return expr;
15866     }
15867
15868   /* We might be trying to synchronize on a STRING_CST */
15869   if ((tmp = patch_string (expr)))
15870     expr = tmp;
15871
15872   /* The TYPE of expr must be a reference type */
15873   if (!JREFERENCE_TYPE_P (TREE_TYPE (expr)))
15874     {
15875       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15876       parse_error_context (wfl_operator, "Incompatible type for %<synchronized%>. Can't convert %qs to %<java.lang.Object%>",
15877                            lang_printable_name (TREE_TYPE (expr), 0));
15878       return error_mark_node;
15879     }
15880
15881   /* Generate a try-finally for the synchronized statement, except
15882      that the handler that catches all throw exception calls
15883      _Jv_MonitorExit and then rethrow the exception.
15884      The synchronized statement is then implemented as:
15885      TRY
15886        {
15887          _Jv_MonitorEnter (expression)
15888          synchronized_block
15889          _Jv_MonitorExit (expression)
15890        }
15891      CATCH_ALL
15892        {
15893          e = _Jv_exception_info ();
15894          _Jv_MonitorExit (expression)
15895          Throw (e);
15896        } */
15897
15898   expr_decl = build_decl (VAR_DECL, generate_name (), TREE_TYPE (expr));
15899   BUILD_MONITOR_ENTER (enter, expr_decl);
15900   BUILD_MONITOR_EXIT (exit, expr_decl);
15901   CAN_COMPLETE_NORMALLY (enter) = 1;
15902   CAN_COMPLETE_NORMALLY (exit) = 1;
15903   assignment = build2 (MODIFY_EXPR, NULL_TREE, expr_decl, expr);
15904   TREE_SIDE_EFFECTS (assignment) = 1;
15905   node = build2 (COMPOUND_EXPR, NULL_TREE,
15906                  build2 (COMPOUND_EXPR, NULL_TREE, assignment, enter),
15907                  build2 (TRY_FINALLY_EXPR, NULL_TREE, block, exit));
15908   node = build_expr_block (node, expr_decl);
15909
15910   return java_complete_tree (node);
15911 }
15912
15913 /* 14.16 The throw Statement */
15914
15915 static tree
15916 patch_throw_statement (tree node, tree wfl_op1)
15917 {
15918   tree expr = TREE_OPERAND (node, 0);
15919   tree type = TREE_TYPE (expr);
15920   int unchecked_ok = 0, tryblock_throws_ok = 0;
15921
15922   /* Thrown expression must be assignable to java.lang.Throwable */
15923   if (!try_reference_assignconv (throwable_type_node, expr))
15924     {
15925       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15926       parse_error_context (wfl_operator,
15927     "Can't throw %qs; it must be a subclass of class %<java.lang.Throwable%>",
15928                            lang_printable_name (type, 0));
15929       /* If the thrown expression was a reference, we further the
15930          compile-time check. */
15931       if (!JREFERENCE_TYPE_P (type))
15932         return error_mark_node;
15933     }
15934
15935   /* At least one of the following must be true */
15936
15937   /* The type of the throw expression is a not checked exception,
15938      i.e. is a unchecked expression. */
15939   unchecked_ok = IS_UNCHECKED_EXCEPTION_P (TREE_TYPE (type));
15940
15941   SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
15942   /* An instance can't throw a checked exception unless that exception
15943      is explicitly declared in the `throws' clause of each
15944      constructor. This doesn't apply to anonymous classes, since they
15945      don't have declared constructors. */
15946   if (!unchecked_ok
15947       && DECL_INSTINIT_P (current_function_decl)
15948       && !ANONYMOUS_CLASS_P (current_class))
15949     {
15950       tree current;
15951       for (current = TYPE_METHODS (current_class); current;
15952            current = TREE_CHAIN (current))
15953         if (DECL_CONSTRUCTOR_P (current)
15954             && !check_thrown_exceptions_do (TREE_TYPE (expr)))
15955           {
15956             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)",
15957                                  lang_printable_name (TREE_TYPE (expr), 0));
15958             return error_mark_node;
15959           }
15960     }
15961
15962   /* Throw is contained in a try statement and at least one catch
15963      clause can receive the thrown expression or the current method is
15964      declared to throw such an exception. Or, the throw statement is
15965      contained in a method or constructor declaration and the type of
15966      the Expression is assignable to at least one type listed in the
15967      throws clause the declaration. */
15968   if (!unchecked_ok)
15969     tryblock_throws_ok = check_thrown_exceptions_do (TREE_TYPE (expr));
15970   if (!(unchecked_ok || tryblock_throws_ok))
15971     {
15972       /* If there is a surrounding try block that has no matching
15973          clatch clause, report it first. A surrounding try block exits
15974          only if there is something after the list of checked
15975          exception thrown by the current function (if any). */
15976       if (IN_TRY_BLOCK_P ())
15977         parse_error_context (wfl_operator, "Checked exception %qs can't be caught by any of the catch clause(s) of the surrounding %<try%> block",
15978                              lang_printable_name (type, 0));
15979       /* If we have no surrounding try statement and the method doesn't have
15980          any throws, report it now. FIXME */
15981
15982       /* We report that the exception can't be throw from a try block
15983          in all circumstances but when the `throw' is inside a static
15984          block. */
15985       else if (!EXCEPTIONS_P (currently_caught_type_list)
15986                && !tryblock_throws_ok)
15987         {
15988           if (DECL_CLINIT_P (current_function_decl))
15989             parse_error_context (wfl_operator,
15990                    "Checked exception %qs can't be thrown in initializer",
15991                                  lang_printable_name (type, 0));
15992           else
15993             parse_error_context (wfl_operator,
15994                    "Checked exception %qs isn't thrown from a %<try%> block",
15995                                  lang_printable_name (type, 0));
15996         }
15997       /* Otherwise, the current method doesn't have the appropriate
15998          throws declaration */
15999       else
16000         parse_error_context (wfl_operator, "Checked exception %qs doesn't match any of current method's %<throws%> declaration(s)",
16001                              lang_printable_name (type, 0));
16002       return error_mark_node;
16003     }
16004
16005   if (! flag_emit_class_files)
16006     BUILD_THROW (node, expr);
16007
16008   return node;
16009 }
16010
16011 /* Add EXCEPTION to the throws clause of MDECL.  If MDECL already throws
16012    a super-class of EXCEPTION, keep the superclass instead.  If MDECL already
16013    throws a sub-class of EXCEPTION, replace the sub-class with EXCEPTION.  */
16014 static void
16015 add_exception_to_throws (tree mdecl, tree exception)
16016 {
16017   tree mthrows;
16018
16019   /* Ignore unchecked exceptions. */
16020   if (IS_UNCHECKED_EXCEPTION_P (exception))
16021     return;
16022
16023   for (mthrows = DECL_FUNCTION_THROWS (mdecl);
16024        mthrows; mthrows = TREE_CHAIN (mthrows))
16025     {
16026       if (inherits_from_p (exception, TREE_VALUE (mthrows)))
16027         return;
16028       if (inherits_from_p (TREE_VALUE (mthrows), exception))
16029         {
16030           TREE_VALUE (mthrows) = exception;
16031           return;
16032         }
16033     }
16034
16035   mthrows = DECL_FUNCTION_THROWS (mdecl);
16036   DECL_FUNCTION_THROWS (mdecl) = build_tree_list (mthrows, exception);
16037 }
16038
16039 /* Check that exception said to be thrown by method DECL can be
16040    effectively caught from where DECL is invoked.  THIS_EXPR is the
16041    expression that computes `this' for the method call.  */
16042 static void
16043 check_thrown_exceptions (
16044 #ifdef USE_MAPPED_LOCATION
16045                          source_location location,
16046 #else
16047
16048                          int location,
16049 #endif
16050                          tree decl, tree this_expr)
16051 {
16052   tree throws;
16053   int is_array_call = 0;
16054
16055   /* Skip check within generated methods, such as access$<n>.  */
16056   if (NESTED_FIELD_ACCESS_IDENTIFIER_P (DECL_NAME (current_function_decl)))
16057     return;
16058
16059   if (this_expr != NULL_TREE
16060       && TREE_CODE (TREE_TYPE (this_expr)) == POINTER_TYPE
16061       && TYPE_ARRAY_P (TREE_TYPE (TREE_TYPE (this_expr))))
16062     is_array_call = 1;
16063
16064   /* For all the unchecked exceptions thrown by DECL.  */
16065   for (throws = DECL_FUNCTION_THROWS (decl); throws;
16066        throws = TREE_CHAIN (throws))
16067     if (!check_thrown_exceptions_do (TREE_VALUE (throws)))
16068       {
16069         /* Suppress errors about cloning arrays.  */
16070         if (is_array_call && DECL_NAME (decl) == get_identifier ("clone"))
16071           continue;
16072
16073 #ifdef USE_MAPPED_LOCATION
16074         SET_EXPR_LOCATION (wfl_operator, location);
16075 #else
16076         EXPR_WFL_LINECOL (wfl_operator) = location;
16077 #endif
16078         if (ANONYMOUS_CLASS_P (DECL_CONTEXT (current_function_decl))
16079             && (DECL_FINIT_P (current_function_decl)
16080                 || DECL_INIT_P (current_function_decl)
16081                 || DECL_CONSTRUCTOR_P (current_function_decl)))
16082           {
16083             /* Add "throws" to the initializer's exception list */
16084             tree exception = TREE_VALUE (throws);
16085             add_exception_to_throws (current_function_decl, exception);
16086           }
16087         else if (DECL_FINIT_P (current_function_decl))
16088           {
16089             parse_error_context
16090               (wfl_operator, "Exception %qs can't be thrown in initializer",
16091                lang_printable_name (TREE_VALUE (throws), 0));
16092           }
16093         else
16094           {
16095             parse_error_context
16096               (wfl_operator, "Exception %qs must be caught, or it must be declared in the %<throws%> clause of %qs",
16097                lang_printable_name (TREE_VALUE (throws), 0),
16098                (DECL_INIT_P (current_function_decl) ?
16099                 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))) :
16100                 IDENTIFIER_POINTER (DECL_NAME (current_function_decl))));
16101           }
16102       }
16103 }
16104
16105 /* Return 1 if checked EXCEPTION is caught at the current nesting level of
16106    try-catch blocks, OR is listed in the `throws' clause of the
16107    current method.  */
16108
16109 static int
16110 check_thrown_exceptions_do (tree exception)
16111 {
16112   tree list = currently_caught_type_list;
16113   resolve_and_layout (exception, NULL_TREE);
16114   /* First, all the nested try-catch-finally at that stage. The
16115      last element contains `throws' clause exceptions, if any. */
16116   if (IS_UNCHECKED_EXCEPTION_P (exception))
16117     return 1;
16118   while (list)
16119     {
16120       tree caught;
16121       for (caught = TREE_VALUE (list); caught; caught = TREE_CHAIN (caught))
16122         if (valid_ref_assignconv_cast_p (exception, TREE_VALUE (caught), 0))
16123           return 1;
16124       list = TREE_CHAIN (list);
16125     }
16126   return 0;
16127 }
16128
16129 /* This function goes over all of CLASS_TYPE ctors and checks whether
16130    each of them features at least one unchecked exception in its
16131    `throws' clause. If it's the case, it returns `true', `false'
16132    otherwise.  */
16133
16134 static bool
16135 ctors_unchecked_throws_clause_p (tree class_type)
16136 {
16137   tree current;
16138
16139   for (current = TYPE_METHODS (class_type); current;
16140        current = TREE_CHAIN (current))
16141     {
16142       bool ctu = false; /* Ctor Throws Unchecked */
16143       if (DECL_CONSTRUCTOR_P (current))
16144         {
16145           tree throws;
16146           for (throws = DECL_FUNCTION_THROWS (current); throws && !ctu;
16147                throws = TREE_CHAIN (throws))
16148             if (inherits_from_p (TREE_VALUE (throws), exception_type_node))
16149               ctu = true;
16150         }
16151       /* We return false as we found one ctor that is unfit. */
16152       if (!ctu && DECL_CONSTRUCTOR_P (current))
16153         return false;
16154     }
16155   /* All ctors feature at least one unchecked exception in their
16156      `throws' clause. */
16157   return true;
16158 }
16159
16160 /* 15.24 Conditional Operator ?: */
16161
16162 static tree
16163 patch_conditional_expr (tree node, tree wfl_cond, tree wfl_op1)
16164 {
16165   tree cond = TREE_OPERAND (node, 0);
16166   tree op1 = TREE_OPERAND (node, 1);
16167   tree op2 = TREE_OPERAND (node, 2);
16168   tree resulting_type = NULL_TREE;
16169   tree t1, t2, patched;
16170   int error_found = 0;
16171
16172   /* The condition and operands of ?: might be StringBuffers crafted
16173      as a result of a string concatenation.  Obtain decent ones here.  */
16174   if ((patched = patch_string (cond)))
16175     TREE_OPERAND (node, 0) = cond = patched;
16176   if ((patched = patch_string (op1)))
16177     TREE_OPERAND (node, 1) = op1 = patched;
16178   if ((patched = patch_string (op2)))
16179     TREE_OPERAND (node, 2) = op2 = patched;
16180
16181   t1 = TREE_TYPE (op1);
16182   t2 = TREE_TYPE (op2);
16183
16184   /* The first expression must be a boolean */
16185   if (TREE_TYPE (cond) != boolean_type_node)
16186     {
16187       SET_WFL_OPERATOR (wfl_operator, node, wfl_cond);
16188       parse_error_context (wfl_operator,
16189                "Incompatible type for %<?:%>. Can't convert %qs to %<boolean%>",
16190                            lang_printable_name (TREE_TYPE (cond), 0));
16191       error_found = 1;
16192     }
16193
16194   /* Second and third can be numeric, boolean (i.e. primitive),
16195      references or null. Anything else results in an error */
16196   if (!((JNUMERIC_TYPE_P (t1) && JNUMERIC_TYPE_P (t2))
16197         || ((JREFERENCE_TYPE_P (t1) || op1 == null_pointer_node)
16198             && (JREFERENCE_TYPE_P (t2) || op2 == null_pointer_node))
16199         || (t1 == boolean_type_node && t2 == boolean_type_node)))
16200     error_found = 1;
16201
16202   /* Determine the type of the conditional expression. Same types are
16203      easy to deal with */
16204   else if (t1 == t2)
16205     resulting_type = t1;
16206
16207   /* There are different rules for numeric types */
16208   else if (JNUMERIC_TYPE_P (t1))
16209     {
16210       /* if byte/short found, the resulting type is short */
16211       if ((t1 == byte_type_node && t2 == short_type_node)
16212           || (t1 == short_type_node && t2 == byte_type_node))
16213         resulting_type = short_type_node;
16214
16215       /* If t1 is a constant int and t2 is of type byte, short or char
16216          and t1's value fits in t2, then the resulting type is t2 */
16217       else if ((t1 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 1)))
16218           && JBSC_TYPE_P (t2) && int_fits_type_p (TREE_OPERAND (node, 1), t2))
16219         resulting_type = t2;
16220
16221       /* If t2 is a constant int and t1 is of type byte, short or char
16222          and t2's value fits in t1, then the resulting type is t1 */
16223       else if ((t2 == int_type_node && TREE_CONSTANT (TREE_OPERAND (node, 2)))
16224           && JBSC_TYPE_P (t1) && int_fits_type_p (TREE_OPERAND (node, 2), t1))
16225         resulting_type = t1;
16226
16227       /* Otherwise, binary numeric promotion is applied and the
16228          resulting type is the promoted type of operand 1 and 2 */
16229       else
16230         resulting_type = binary_numeric_promotion (t1, t2,
16231                                                    &TREE_OPERAND (node, 1),
16232                                                    &TREE_OPERAND (node, 2));
16233     }
16234
16235   /* Cases of a reference and a null type */
16236   else if (JREFERENCE_TYPE_P (t1) && op2 == null_pointer_node)
16237     resulting_type = t1;
16238
16239   else if (JREFERENCE_TYPE_P (t2) && op1 == null_pointer_node)
16240     resulting_type = t2;
16241
16242   /* Last case: different reference types. If a type can be converted
16243      into the other one by assignment conversion, the latter
16244      determines the type of the expression */
16245   else if ((resulting_type = try_reference_assignconv (t1, op2)))
16246     resulting_type = promote_type (t1);
16247
16248   else if ((resulting_type = try_reference_assignconv (t2, op1)))
16249     resulting_type = promote_type (t2);
16250
16251   /* If we don't have any resulting type, we're in trouble */
16252   if (!resulting_type)
16253     {
16254       char *t = xstrdup (lang_printable_name (t1, 0));
16255       SET_WFL_OPERATOR (wfl_operator, node, wfl_op1);
16256       parse_error_context (wfl_operator,
16257                  "Incompatible type for %<?:%>. Can't convert %qs to %qs",
16258                            t, lang_printable_name (t2, 0));
16259       free (t);
16260       error_found = 1;
16261     }
16262
16263   if (error_found)
16264     {
16265       TREE_TYPE (node) = error_mark_node;
16266       return error_mark_node;
16267     }
16268
16269   TREE_TYPE (node) = resulting_type;
16270   TREE_SET_CODE (node, COND_EXPR);
16271   CAN_COMPLETE_NORMALLY (node) = 1;
16272   return node;
16273 }
16274
16275 /* Wrap EXPR with code to initialize DECL's class, if appropriate. */
16276
16277 static tree
16278 maybe_build_class_init_for_field (tree decl, tree expr)
16279 {
16280   tree clas = DECL_CONTEXT (decl);
16281   if (flag_emit_class_files)
16282     return expr;
16283
16284   if (TREE_CODE (decl) == VAR_DECL && FIELD_STATIC (decl)
16285       && FIELD_FINAL (decl))
16286     {
16287       tree init = DECL_INITIAL (decl);
16288       if (init != NULL_TREE)
16289         init = fold_constant_for_init (init, decl);
16290       if (init != NULL_TREE && CONSTANT_VALUE_P (init))
16291         return expr;
16292     }
16293
16294   return build_class_init (clas, expr);
16295 }
16296
16297 /* Try to constant fold NODE.
16298    If NODE is not a constant expression, return NULL_EXPR.
16299    CONTEXT is a static final VAR_DECL whose initializer we are folding. */
16300
16301 static tree
16302 fold_constant_for_init (tree node, tree context)
16303 {
16304   tree op0, op1, val;
16305   enum tree_code code = TREE_CODE (node);
16306
16307   switch (code)
16308     {
16309     case INTEGER_CST:
16310       if (node == null_pointer_node)
16311         return NULL_TREE;
16312     case STRING_CST:
16313     case REAL_CST:
16314       return node;
16315
16316     case PLUS_EXPR:
16317     case MINUS_EXPR:
16318     case MULT_EXPR:
16319     case TRUNC_MOD_EXPR:
16320     case RDIV_EXPR:
16321     case LSHIFT_EXPR:
16322     case RSHIFT_EXPR:
16323     case URSHIFT_EXPR:
16324     case BIT_AND_EXPR:
16325     case BIT_XOR_EXPR:
16326     case BIT_IOR_EXPR:
16327     case TRUTH_ANDIF_EXPR:
16328     case TRUTH_ORIF_EXPR:
16329     case EQ_EXPR:
16330     case NE_EXPR:
16331     case GT_EXPR:
16332     case GE_EXPR:
16333     case LT_EXPR:
16334     case LE_EXPR:
16335       op0 = TREE_OPERAND (node, 0);
16336       op1 = TREE_OPERAND (node, 1);
16337       val = fold_constant_for_init (op0, context);
16338       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16339         return NULL_TREE;
16340       TREE_OPERAND (node, 0) = val;
16341       val = fold_constant_for_init (op1, context);
16342       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16343         return NULL_TREE;
16344       TREE_OPERAND (node, 1) = val;
16345       return patch_binop (node, op0, op1, 1);
16346
16347     case UNARY_PLUS_EXPR:
16348     case NEGATE_EXPR:
16349     case TRUTH_NOT_EXPR:
16350     case BIT_NOT_EXPR:
16351     case CONVERT_EXPR:
16352     case NOP_EXPR:
16353       op0 = TREE_OPERAND (node, 0);
16354       val = fold_constant_for_init (op0, context);
16355       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16356         return NULL_TREE;
16357       TREE_OPERAND (node, 0) = val;
16358       val = patch_unaryop (node, op0);
16359       if (! TREE_CONSTANT (val))
16360         return NULL_TREE;
16361       return val;
16362
16363       break;
16364
16365     case COND_EXPR:
16366       val = fold_constant_for_init (TREE_OPERAND (node, 0), context);
16367       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16368         return NULL_TREE;
16369       TREE_OPERAND (node, 0) = val;
16370       val = fold_constant_for_init (TREE_OPERAND (node, 1), context);
16371       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16372         return NULL_TREE;
16373       TREE_OPERAND (node, 1) = val;
16374       val = fold_constant_for_init (TREE_OPERAND (node, 2), context);
16375       if (val == NULL_TREE || ! TREE_CONSTANT (val))
16376         return NULL_TREE;
16377       TREE_OPERAND (node, 2) = val;
16378       return integer_zerop (TREE_OPERAND (node, 0)) ? TREE_OPERAND (node, 2)
16379         : TREE_OPERAND (node, 1);
16380
16381     case VAR_DECL:
16382     case FIELD_DECL:
16383       if (! FIELD_FINAL (node)
16384           || DECL_INITIAL (node) == NULL_TREE)
16385         return NULL_TREE;
16386       val = DECL_INITIAL (node);
16387       /* Guard against infinite recursion. */
16388       DECL_INITIAL (node) = NULL_TREE;
16389       val = fold_constant_for_init (val, node);
16390       if (val != NULL_TREE && TREE_CODE (val) != STRING_CST)
16391         val = try_builtin_assignconv (NULL_TREE, TREE_TYPE (node), val);
16392       DECL_INITIAL (node) = val;
16393       return val;
16394
16395     case EXPR_WITH_FILE_LOCATION:
16396       /* Compare java_complete_tree and resolve_expression_name. */
16397       if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
16398           || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
16399         {
16400           tree name = EXPR_WFL_NODE (node);
16401           tree decl;
16402           if (PRIMARY_P (node))
16403             return NULL_TREE;
16404           else if (! QUALIFIED_P (name))
16405             {
16406               decl = lookup_field_wrapper (DECL_CONTEXT (context), name);
16407               if (decl == NULL_TREE
16408                   || (! FIELD_STATIC (decl) && ! FIELD_FINAL (decl)))
16409                 return NULL_TREE;
16410               return fold_constant_for_init (decl, decl);
16411             }
16412           else
16413             {
16414               tree r = NULL_TREE;
16415               /* Install the proper context for the field resolution.  */
16416               tree saved_current_class = current_class;
16417               /* Wait until the USE_COMPONENT_REF re-write.  FIXME. */
16418               current_class = DECL_CONTEXT (context);
16419               qualify_ambiguous_name (node);
16420               r = resolve_field_access (node, &decl, NULL);
16421               /* Restore prior context.  */
16422               current_class = saved_current_class;
16423               if (r != error_mark_node && decl != NULL_TREE)
16424                 return fold_constant_for_init (decl, decl);
16425               return NULL_TREE;
16426             }
16427         }
16428       else
16429         {
16430           op0 = TREE_OPERAND (node, 0);
16431           val = fold_constant_for_init (op0, context);
16432           if (val == NULL_TREE || ! TREE_CONSTANT (val))
16433             return NULL_TREE;
16434           TREE_OPERAND (node, 0) = val;
16435           return val;
16436         }
16437
16438 #ifdef USE_COMPONENT_REF
16439     case IDENTIFIER:
16440     case COMPONENT_REF:
16441       ?;
16442 #endif
16443
16444     default:
16445       return NULL_TREE;
16446     }
16447 }
16448
16449 #ifdef USE_COMPONENT_REF
16450 /* Context is 'T' for TypeName, 'P' for PackageName,
16451    'M' for MethodName, 'E' for ExpressionName, and 'A' for AmbiguousName. */
16452
16453 tree
16454 resolve_simple_name (tree name, int context)
16455 {
16456 }
16457
16458 tree
16459 resolve_qualified_name (tree name, int context)
16460 {
16461 }
16462 #endif
16463
16464 void
16465 init_src_parse (void)
16466 {
16467   /* Sanity check; we've been bit by this before.  */
16468   if (ARRAY_SIZE (ctxp->modifier_ctx) != MODIFIER_TK - PUBLIC_TK)
16469     abort ();
16470 }
16471
16472 \f
16473
16474 /* This section deals with the functions that are called when tables
16475    recording class initialization information are traversed.  */
16476
16477 /* This function is called for each class that is known definitely
16478    initialized when a given static method was called. This function
16479    augments a compound expression (INFO) storing all assignment to
16480    initialized static class flags if a flag already existed, otherwise
16481    a new one is created.  */
16482
16483 static int
16484 emit_test_initialization (void **entry_p, void *info)
16485 {
16486   tree l = (tree) info;
16487   tree decl, init;
16488   tree key = (tree) *entry_p;
16489   tree *ite;
16490   htab_t cf_ht = DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl);
16491
16492   /* If we haven't found a flag and we're dealing with self registered
16493      with current_function_decl, then don't do anything. Self is
16494      always added as definitely initialized but this information is
16495      valid only if used outside the current function. */
16496   if (current_function_decl == TREE_PURPOSE (l)
16497       && java_treetreehash_find (cf_ht, key) == NULL)
16498     return true;
16499
16500   ite = java_treetreehash_new (cf_ht, key);
16501
16502   /* If we don't have a variable, create one and install it. */
16503   if (*ite == NULL)
16504     {
16505       tree block;
16506
16507       decl = build_decl (VAR_DECL, NULL_TREE, boolean_type_node);
16508       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
16509       LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
16510       DECL_CONTEXT (decl) = current_function_decl;
16511       DECL_INITIAL (decl) = boolean_true_node;
16512       /* Don't emit any symbolic debugging info for this decl.  */
16513       DECL_IGNORED_P (decl) = 1;
16514
16515       /* The trick is to find the right context for it. */
16516       block = BLOCK_SUBBLOCKS (GET_CURRENT_BLOCK (current_function_decl));
16517       TREE_CHAIN (decl) = BLOCK_EXPR_DECLS (block);
16518       BLOCK_EXPR_DECLS (block) = decl;
16519       *ite = decl;
16520     }
16521   else
16522     decl = *ite;
16523
16524   /* Now simply augment the compound that holds all the assignments
16525      pertaining to this method invocation. */
16526   init = build2 (MODIFY_EXPR, boolean_type_node, decl, boolean_true_node);
16527   TREE_SIDE_EFFECTS (init) = 1;
16528   TREE_VALUE (l) = add_stmt_to_compound (TREE_VALUE (l), void_type_node, init);
16529   TREE_SIDE_EFFECTS (TREE_VALUE (l)) = 1;
16530
16531   return true;
16532 }
16533
16534 #ifdef __XGETTEXT__
16535 /* Depending on the version of Bison used to compile this grammar,
16536    it may issue generic diagnostics spelled "syntax error" or
16537    "parse error".  To prevent this from changing the translation
16538    template randomly, we list all the variants of this particular
16539    diagnostic here.  Translators: there is no fine distinction
16540    between diagnostics with "syntax error" in them, and diagnostics
16541    with "parse error" in them.  It's okay to give them both the same
16542    translation.  */
16543 const char d1[] = N_("syntax error");
16544 const char d2[] = N_("parse error");
16545 const char d3[] = N_("syntax error; also virtual memory exhausted");
16546 const char d4[] = N_("parse error; also virtual memory exhausted");
16547 const char d5[] = N_("syntax error: cannot back up");
16548 const char d6[] = N_("parse error: cannot back up");
16549 #endif
16550
16551 #include "gt-java-parse.h"
16552 #include "gtype-java.h"